Accentsconagua
Share
RxJava is een van de meest populaire bibliotheken om reactieve programmering naar het Android-platform te brengen en in deze driedelige serie heb ik je laten zien hoe je deze bibliotheek in je eigen Android-projecten kunt gebruiken.
In Aan de slag met RxJava 2 voor Android hebben we gekeken naar wat RxJava is en wat het Android-ontwikkelaars te bieden heeft, voordat een Hello World-app werd gemaakt die de drie kerncomponenten van RxJava demonstreerde: een waarneembaar, een Waarnemer, en een abonnement.
In de zelfstudie Reactive Programming Operators in RxJava 2 hebben we gekeken hoe we complexe datatransformaties kunnen uitvoeren met behulp van operatoren en hoe we kunnen combineren operators en Schedulers om multithreading op Android eindelijk een pijnvrije ervaring te maken.
We hebben ook RxAndroid aangeraakt, een bibliotheek die speciaal is ontworpen om u te helpen RxJava in uw Android-projecten te gebruiken, maar er is nog veel meer te ontdekken in RxAndroid. Dus, in deze post ga ik me uitsluitend richten op de RxAndroid-familie van bibliotheken.
Net zoals RxJava, onderging RxAndroid een enorme revisie in versie 2 versie. Het RxAndroid-team heeft besloten om de bibliotheek te modulariseren door een groot deel van de functionaliteit naar speciale RxAndroid add-on-modules te verplaatsen.
In dit artikel laat ik je zien hoe je een aantal van de meest populaire en krachtige RxAndroid-modules kunt instellen en gebruiken, inclusief een bibliotheek die luisteraars, handlers en TextWatchers iets uit het verleden door u de mogelijkheid te geven om te handelen ieder Android UI-evenement als een waarneembaar.
En omdat geheugenlekken veroorzaakt door onvolledige abonnementen het grootste nadeel zijn van het gebruik van RxJava in uw Android-apps, zal ik u ook laten zien hoe u een RxAndroid-module gebruikt die het abonnement voor u aankan. Aan het einde van dit artikel weet u hoe u RxJava in welke dan ook kunt gebruiken Activiteit of Fragment, zonder het risico te lopen tegen te komen ieder RxJava-gerelateerde geheugenlekken.
Reageren op UI-gebeurtenissen zoals tikken, swipes en tekstinvoer is een fundamenteel onderdeel van het ontwikkelen van vrijwel elke Android-app, maar de behandeling van Android UI-evenementen is niet bijzonder eenvoudig.
Je reageert meestal op UI-gebeurtenissen met een combinatie van luisteraars, handlers, TextWatchers, en mogelijk andere componenten, afhankelijk van het type gebruikersinterface dat u maakt. Voor elk van deze componenten moet u een aanzienlijke hoeveelheid boilerplate-code schrijven en om het nog erger te maken, is er geen consistentie in de manier waarop u deze verschillende componenten implementeert. U kunt bijvoorbeeld omgaan Bij klikken evenementen door het implementeren van een OnClickListener:
Knop knop = (Knop) findViewById (R.id.button); button.setOnClickListener (nieuwe View.OnClickListener () @Override public void onClick (View v) // Voer wat werk //);
Maar dit is heel anders dan hoe u een TextWatcher zou implementeren:
final EditText name = (EditText) v.findViewById (R.id.name); // Maak een TextWatcher en geef aan dat deze TextWatcher moet worden aangeroepen wanneer de inhoud van EditText verandert // name.addTextChangedListener (new TextWatcher () @Override public void beforeTextChanged (CharSequence s, int start, int count, int after) @ Overschrijf openbare leegte onTextChanged (CharSequence s, int start, int before, int count) // Voer wat werk // @Override public void afterTextChanged (Editable s) );
Dit gebrek aan consistentie kan mogelijk een grote complexiteit aan uw code toevoegen. En als u UI-componenten hebt die afhankelijk zijn van de uitvoer van andere UI-componenten, maakt u zich dan op voor dingen die nog ingewikkelder worden! Zelfs een eenvoudige use-case, zoals het vragen aan de gebruiker om zijn naam in te voeren in een Tekst bewerken dus je kunt de tekst die in de volgende verschijnt personaliseren TextViews-vereist geneste callbacks, die notoir moeilijk te implementeren en te onderhouden zijn. (Sommige mensen verwijzen naar geneste callbacks als "callback hell.")
Het is duidelijk dat een gestandaardiseerde aanpak voor het afhandelen van UI-gebeurtenissen uw code aanzienlijk kan vereenvoudigen, en RxBinding is een bibliotheek die precies dat wil doen, door bindingen te bieden waarmee u Android kunt converteren Uitzicht evenement in een waarneembaar.
Zodra u een weergavegebeurtenis heeft geconverteerd naar een waarneembaar, het zal zijn UI-evenementen uitzenden als gegevensstromen waarop je je kunt abonneren op precies dezelfde manier als waarop je je abonneert op een ander waarneembaar.
We hebben al gezien hoe je een klikgebeurtenis kunt maken met de Android-standaard OnClickListener, laten we kijken hoe je dezelfde resultaten behaalt met RxBinding:
import com.jakewharton.rxbinding.view.RxView; ... Knop button = (Button) findViewById (R.id.button); RxView.clicks (knop) .subscribe (aVoid -> // Voer hier wat werk uit //);
Deze benadering is niet alleen beknopter, maar het is een standaardimplementatie die u kunt toepassen op alle gebruikersinteracties die in uw app plaatsvinden. Het vastleggen van tekstinvoer verloopt bijvoorbeeld volgens hetzelfde patroon als het vastleggen van klikgebeurtenissen:
RxTextView.textChanges (editText) .subscribe (charSequence -> // Voer hier wat werk uit //);
U kunt dus precies zien hoe RxBinding de UI-gerelateerde code van uw app kan vereenvoudigen. Laten we een app maken die een paar van deze bindingen in actie demonstreert. Ik ga ook een Uitzicht dat is afhankelijk van de uitvoer van een ander Uitzicht, om aan te tonen hoe RxBinding het maken van relaties tussen UI-componenten vereenvoudigt.
Deze app zal bestaan uit:
Knop dat toont een Geroosterd brood wanneer getikt.Tekst bewerken die tekstwijzigingen detecteert.Tekstweergave die updates om de inhoud van de Tekst bewerken.Maak een Android Studio-project met de instellingen van uw keuze en open vervolgens uw moduleniveau build.gradle bestand en voeg de nieuwste versie van de RxBinding-bibliotheek toe als een projectafhankelijkheid. In het belang van het minimaal houden van ketelsteencode, ga ik ook lambda's gebruiken, dus heb ik mijn build.gradle bestand om deze Java 8-functie te ondersteunen:
plug-in toepassen: 'com.android.application' android compileSdkVersion 25 buildToolsVersion "25.0.2" defaultConfig applicationId "com.jessicathornsby.myapplication" minSdkVersion 23 targetSdkVersion 25 versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner. AndroidJUnitRunner "// Activeer de Jack toolchain // jackOptions enabled true buildTypes release minifyEnabled false proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' // Stel sourceCompatibility en targetCompatibility in op JavaVersion.VERSION_1_8 // compileOptions sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 dependencies compile fileTree (dir: 'libs', include: ['* .jar']) androidTestCompile ('com.android.support.test.espresso : espresso-core: 2.2.2 ', exclude group:' com.android.support ', module:' support-annotations ') // Voeg de kernbibliotheek RxBinding toe // compile' com.jakewharton.rxbinding: rxbinding: 0.4.0 'compileer' com .android.support: appcompat-v7: 25.3.0 '// Vergeet niet om de afhankelijkheden van RxJava en RxAndroid toe te voegen // compile' io.reactivex.rxjava2: rxandroid: 2.0.1 'compileer' io.reactivex.rxjava2: rxjava: 2.0.5 'testCompile' junit: junit: 4.12 ' Wanneer u met meerdere RxJava-bibliotheken werkt, is het mogelijk dat u een Dubbele bestanden gekopieerd in APK META-INF / DEPENDENCIES foutmelding tijdens het compileren. Als u deze fout tegenkomt, is de oplossing om deze dubbele bestanden te onderdrukken door het volgende toe te voegen aan uw moduleniveau build.gradle het dossier:
android packagingOptions // Gebruik "uitsluiten" om te verwijzen naar het specifieke bestand (of de bestanden) waarover Android Studio klaagt // // 'META-INF / rxjava.properties' uitsluiten
Synchroniseer uw Gradle-bestanden en maak vervolgens een lay-out die bestaat uit a Knop, een Tekst bewerken, en een Tekstweergave:
Laten we nu kijken naar hoe u deze RxBinding zou gebruiken om de verschillende UI-gebeurtenissen vast te leggen waarop onze applicatie moet reageren. Om te beginnen, declareer uw invoer en definieer de Hoofdactiviteit klasse.
pakket com.jessicathornsby.myapplication; import android.os.Bundle; import android.support.v7.app.AppCompatActivity; importeer android.widget.Button; importeer android.widget.EditText; import android.widget.TextView; import android.widget.Toast; // Importeer de klasse view.RxView, zodat u RxView.clicks // import com.jakewharton.rxbinding.view.RxView kunt gebruiken; // Importeer widget.RxTextView zodat u RxTextView.textChanges // import com.jakewharton.rxbinding.widget.RxTextView kunt gebruiken; public class MainActivity breidt AppCompatActivity uit @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); Knop knop = (Knop) findViewById (R.id.button); TextView textView = (TextView) findViewById (R.id.textView); EditText editText = (EditText) findViewById (R.id.editText); // Code voor de bindingen gaat hier // // ... //
Nu kunt u beginnen met het toevoegen van bindingen om te reageren op UI-gebeurtenissen. De RxView.clicks methode wordt gebruikt om klikgebeurtenissen te binden. Maak een binding om een toast weer te geven wanneer op de knop wordt geklikt:
RxView.clicks (knop) .subscribe (aVoid -> Toast.makeText (MainActivity.this, "RxView.clicks", Toast.LENGTH_SHORT) .show (););
Gebruik vervolgens de RxTextView.textChanges () methode om te reageren op een tekstwijzigingsgebeurtenis door de Tekstweergave met de inhoud van onze Tekst bewerken.
RxTextView.textChanges (editText) .subscribe (charSequence -> textView.setText (charSequence););
Wanneer u uw app uitvoert, krijgt u een scherm zoals het volgende.
Installeer uw project op een fysieke Android-smartphone of -tablet of een compatibele AVD en besteed vervolgens enige tijd aan interactie met de verschillende UI-elementen. Uw app moet reageren op klikgebeurtenissen en tekstinvoer zoals normaal - en allemaal zonder een luisteraar, TextWatcher of terugbellen in zicht!
Hoewel de kernbibliotheek van RxBinding bindingen biedt voor alle UI-elementen die deel uitmaken van het standaard Android-platform, zijn er ook RxBinding-siblingmodules die koppelingen bieden voor weergaven die deel uitmaken van de verschillende ondersteuningsbibliotheken van Android..
Als u een of meer ondersteuningsbibliotheken aan uw project hebt toegevoegd, wilt u meestal ook de bijbehorende RxBinding-module toevoegen.
Deze sibling-modules volgen een eenvoudige naamgevingsconventie die het gemakkelijk maakt om de bijbehorende Android-ondersteuningsbibliotheek te identificeren: elke sibling-module neemt eenvoudig de naam van de ondersteuningsbibliotheek en vervangt deze com.android met com.jakewharton.rxbinding2: rxbinding.
compile com.jakewharton.rxbinding2: rxbinding-recyclerview-v7: 2.0.0 'compile 'com.jakewharton.rxbinding2: rxbinding-support-v4: 2.0.0'compile 'com.jakewharton.rxbinding2: rxbinding-appcompat-v7: 2.0.0'compile 'com.jakewharton.rxbinding2: rxbinding-design: 2.0.0'compileer 'com.jakewharton.rxbinding2: rxbinding-recyclerview-v7: 2.0.0'compile 'com.jakewharton.rxbinding2: rxbinding-leanback-v17: 2.0.0'Als je Kotlin gebruikt in je Android-projecten, dan is er ook een Kotlin-versie beschikbaar voor elke RxBinding-module. Om toegang te krijgen tot de Kotlin-versie, voegt u gewoon toe -Kotlin naar de naam van de bibliotheek waarmee u wilt werken, dus:
compile 'com.jakewharton.rxbinding2: rxbinding-design: 2.0.0'
Wordt:
compileer 'com.jakewharton.rxbinding2: rxbinding-design-kotlin: 2.0.0'
Zodra je een hebt omgezet Uitzicht evenement in een waarneembaar, al deze gebeurtenissen worden uitgezonden als een gegevensstroom. Zoals we al hebben gezien, kunt u zich abonneren op deze streams en vervolgens elke taak uitvoeren die u nodig hebt om deze specifieke UI-gebeurtenis te activeren, zoals het weergeven van een Geroosterd brood of bijwerken van een Tekstweergave. U kunt echter ook een enorme verzameling operators van RxJava toepassen op deze waarneembare stream en zelfs meerdere operatoren aan elkaar koppelen om complexe transformaties uit te voeren op uw UI-evenementen.
Er zijn veel te veel operatoren om te bespreken in een enkel artikel (en de officiële documenten bevatten sowieso al de operatoren) maar als het gaat om het werken met Android UI-evenementen, zijn er een paar operators die bijzonder handig kunnen zijn.
ontdendering () operatorTen eerste, als u bang bent dat een ongeduldige gebruiker herhaaldelijk een UI-element kan aftappen, waardoor uw app mogelijk in de war komt, kunt u de app gebruiken ontdendering () operator om alle UI-gebeurtenissen die snel achter elkaar worden verzonden, eruit te filteren.
In het volgende voorbeeld geef ik aan dat deze knop moet reageren op een Bij klikken gebeurtenis alleen als er ten minste een onderbreking van 500 milliseconden is opgetreden sinds de vorige klikgebeurtenis:
RxView.clicks (knop) .debounce (500, TimeUnit.MILLISECONDS) .subscribe (aVoid -> Toast.makeText (MainActivity.this, "RxView.clicks", Toast.LENGTH_SHORT) .show (););
publiceren() operatorU kunt ook de publiceren() om meerdere luisteraars aan dezelfde weergave te koppelen, iets dat traditioneel moeilijk te implementeren is in Android.
De publiceren() operator converteert een standaard waarneembaar in een aansluitbaar waarneembaar. Terwijl een regelmatige waarneembaar items begint uit te zenden zodra de eerste waarnemer het onderschrijft, zal een te verbinden observeerbaar niets uitstoten totdat je het expliciet instrueert, door het toepassen van de aansluiten() operator. Dit geeft u een kans om meerdere waarnemers te abonneren, zonder dat de waarneembare start om items uit te zenden zodra het eerste abonnement plaatsvindt.
Nadat u al uw abonnementen hebt aangemaakt, past u eenvoudig het aansluiten() operator en de waarneembare data zullen beginnen uitzenden naar alle toegewezen waarnemers.
Zoals we in deze serie hebben gezien, kan RxJava een krachtige tool zijn voor het maken van reactievere, interactieve Android-apps, met veel minder code dan je normaal alleen met Java zou moeten krijgen. Er is echter een groot nadeel aan het gebruik van RxJava in uw Android-toepassingen - het potentieel voor geheugenlekken veroorzaakt door onvolledige abonnementen.
Deze geheugenlekken treden op wanneer het Android-systeem een probeert te vernietigen Activiteit die een run bevat waarneembaar. Aangezien het waarneembare is uitgevoerd, zal zijn waarnemer nog steeds een verwijzing naar de activiteit bevatten, en het systeem zal niet in staat zijn om deze activiteit als een resultaat te verzamelen..
Omdat Android vernietigt en recreëert ActiviteitElke keer dat de configuratie van het apparaat verandert, kan uw app een duplicaat maken Activiteit elke keer dat de gebruiker overschakelt tussen portret- en landschapsmodus, en telkens wanneer zij het toetsenbord van het apparaat openen en sluiten.
Deze activiteiten zullen op de achtergrond rondhangen, waarbij mogelijk nooit afval wordt verzameld. Omdat Activiteiten grote objecten zijn, kan dit snel leiden ernstig problemen met geheugenbeheer, vooral omdat Android-smartphones en tablets in het begin een beperkt geheugen hebben. De combinatie van een groot geheugenlek en beperkt geheugen kan snel resulteren in een Geheugen vol fout.
RxJava-geheugenlekken kunnen mogelijk de werking van uw toepassing beschadigen, maar er is een RxAndroid-bibliotheek waarmee u RxJava in uw app kunt gebruiken zonder dat u zich zorgen hoeft te maken over geheugenlekken.
De RxLifecycle-bibliotheek, ontwikkeld door Trello, biedt levenscyclusafhandeling API's die u kunt gebruiken om de levensduur van een waarneembaar naar de levenscyclus van een Activiteit of Fragment. Zodra deze verbinding tot stand is gebracht, zal RxLifecycle de waarneemsequentie beëindigen als reactie op levenscyclusgebeurtenissen die plaatsvinden in de toegewezen activiteit of het fragment van die waarneembare. Dit betekent dat je een waarneembaar kunt maken dat automatisch wordt beëindigd wanneer een activiteit of fragment wordt vernietigd.
Merk op dat we het hier over hebben terminating een reeks, en niet uitschrijven. Hoewel RxLifecycle vaak wordt besproken in het kader van het beheer van het abonnement / uitschrijvingproces, technisch gezien het wordt niet afgemeld voor een waarnemer. In plaats daarvan beëindigt de RxLifecycle-bibliotheek de waarneembare sequentie door het verzenden van de onComplete () of OnError () methode. Wanneer u zich afmeldt, stopt de waarnemer met het ontvangen van meldingen van waarneembaar, zelfs als dat waarneembare nog steeds items uitzendt. Als u specifiek afmeldingsgedrag nodig heeft, dan is dat iets dat u zelf moet implementeren.
Als u RxLifecycle in uw Android-projecten wilt gebruiken, opent u uw moduleniveau build.gradle bestand en voeg de nieuwste versie van de RxLifeycle-bibliotheek toe, plus de RxLifecycle Android-bibliotheek:
afhankelijkheden ... compile 'com.trello.rxlifecycle2: rxlifecycle: 2.0.1' compile 'com.trello.rxlifecycle2: rxlifecycle-android: 2.0.1'
Vervolgens in de Activiteit of Fragment waar u de API's voor levenscyclusafhandeling van de bibliotheek wilt gebruiken, kunt u deze ook uitbreiden RxActivity, RxAppCompatActivity of RxFragment, en voeg de bijbehorende importinstructie toe, bijvoorbeeld:
import com.trello.rxlifecycle2.components.support.RxAppCompatActivity; ... public class MainActivity breidt RxAppCompatActivity uit
Als het gaat om het binden van een waarneembaar naar de levenscyclus van een Activiteit of Fragment, u kunt de levenscyclusgebeurtenis specificeren waar de waarneembare moet eindigen, of u kunt de RxLifecycle-bibliotheek laten beslissen wanneer het de waarneembare sequentie moet beëindigen.
Standaard beëindigt RxLifecycle een waarneembaar onderdeel in de aanvullende levenscyclusgebeurtenis tot die waarin dat abonnement plaatsvond, dus als u zich abonneert op een waarneembaar object tijdens de activiteit van uw activiteit onCreate () methode, dan zal RxLifecycle de waarneembare sequentie tijdens die Activiteit beëindigen onDestroy () methode. Als u zich abonneert tijdens een Fragment's onAttach () methode, dan zal RxLifecycle deze reeks beëindigen in de onDetach () methode.
U kunt deze beslissing overlaten aan RxLifecycle, door het gebruik van RxLifecycleAndroid.bindActivity:
waarneembaarmyObservable = Observable.range (0, 25); ... @Override public void onResume () super.onResume (); myObservable .compose (RxLifecycleAndroid.bindActivity (lifecycle)) .subscribe ();
U kunt ook de levenscyclusgebeurtenis opgeven waarbij RxLifecycle a moet beëindigen waarneembaar volgorde, met RxLifecycle.bindUntilEvent.
Hier specificeer ik dat de waarneembare sequentie moet worden beëindigd in onDestroy ():
@Override public void onResume () super.onResume (); myObservable .compose (RxLifecycle.bindUntilEvent (lifecycle, ActivityEvent.DESTROY)) .subscribe ();
De uiteindelijke bibliotheek waar we naar gaan kijken is RxPermissions, die is ontworpen om je te helpen RxJava te gebruiken met het nieuwe toestemmingsmodel dat is geïntroduceerd in Android 6.0. Met deze bibliotheek kunt u ook een toestemmingsaanvraag indienen en het toestemmingsresultaat op dezelfde locatie afhandelen, in plaats van de toestemming op één plaats te vragen en de resultaten afzonderlijk af te handelen, in Activity.onRequestPermissionsResult ().
Begin door de bibliotheek RxPermissions toe te voegen aan uw build.gradle het dossier:
compile 'com.tbruyelle.rxpermissions2: rxpermissions: 0.9.3@aar'
Maak vervolgens een instantie RxPermissions:
RxPermissions rxPermissions = new RxPermissions (this);
U bent dan klaar om autorisatieverzoeken te doen via de bibliotheek RxPermissions met behulp van de volgende formule:
rxPermissions.request (Manifest.permission.READ_CONTACTS) .subscribe (verleend -> if (verleend) // De machtiging is verleend // else // De machtiging is geweigerd //);
Waar u geeft uw toestemmingsverzoek af is cruciaal, omdat er altijd een kans is dat de hosting Activiteit kan worden vernietigd en vervolgens opnieuw worden gemaakt terwijl het toestemmingendialoogvenster op het scherm staat, meestal als gevolg van een configuratiewijziging zoals de gebruiker die zich verplaatst tussen staande en liggende modi. Als dit gebeurt, wordt uw abonnement mogelijk niet opnieuw aangemaakt, wat betekent dat u niet geabonneerd bent op de waarneembare RxPermissions en het antwoord van de gebruiker niet ontvangt in het dialoogvenster met de autorisatieaanvraag. Om te garanderen dat uw toepassing de reactie van de gebruiker ontvangt, altijd uw aanvraag inroepen tijdens een initialisatiefase zoals Activity.onCreate (), Activity.onResume (), of View.onFinishInflate ().
Het is niet ongebruikelijk dat functies verschillende rechten vereisen. Als u een sms-bericht wilt verzenden, moet uw app bijvoorbeeld meestal de VERSTUUR SMS en READ_CONTACTS toestemmingen. De RxPermissions-bibliotheek biedt een beknopte methode om meerdere machtigingsverzoeken uit te vaardigen en vervolgens de antwoorden van de gebruiker te combineren in één vals (een of meer machtigingen zijn geweigerd) of waar (alle toestemmingen werden verleend) antwoord dat u vervolgens dienovereenkomstig kunt reageren.
RxPermissions.getInstance (this) .request (Manifest.permission.SEND_SMS, Manifest.permission.READ_CONTACTS) .subscribe (verleend -> if (verleend) // Alle machtigingen zijn verleend // else // Een of meer machtigingen werd geweigerd// );
U wilt meestal een machtigingsverzoek activeren als reactie op een UI-gebeurtenis, bijvoorbeeld wanneer de gebruiker op een menu-item of knop tikt, dus RxPermissions en RxBiding zijn twee bibliotheken die bijzonder goed samenwerken.
Het behandelen van de UI-gebeurtenis als een waarneembaar document en het maken van de toestemmingsaanvraag via RxPermissions, stelt u in staat om veel werk te verrichten met slechts enkele regels code:
RxView.clicks (findViewById (R.id.enableBluetooth)) .compose (RxPermissions.getInstance (this) .ensure (Manifest.permission.BLUETOOTH_ADMIN)) .subscribe (verleend -> // Op de knop 'enableBluetooth' is geklikt / /);
Na het lezen van dit artikel, heb je enkele ideeën over hoe je veel boilerplate-code uit je Android-apps kunt knippen - met behulp van RxJava om alle UI-gebeurtenissen van je applicatie af te handelen en je toestemmingsverzoeken via RxPermissions af te geven. We hebben ook gekeken naar hoe je RxJava in elk Android kunt gebruiken Activiteit of Fragment, zonder zich zorgen te maken over de geheugenlekken die kunnen ontstaan door onvolledige abonnementen.
We hebben een aantal van de meest populaire en nuttige RxJava- en RxAndroid-bibliotheken in deze serie verkend, maar als je graag wilt zien wat RxJava nog meer Android-ontwikkelaars te bieden heeft, bekijk dan enkele van de vele andere RxAndroid-bibliotheken. Je vindt een uitgebreide lijst met extra RxAndroid-bibliotheken op GitHub.
Bekijk in de tussentijd een aantal van onze andere Android-ontwikkelingsposten hier op Envato Tuts+!
