Accentsconagua
Share
RxJava ist eine der beliebtesten Bibliotheken, um reaktive Programmierung auf die Android-Plattform zu bringen. In dieser dreiteiligen Serie habe ich Ihnen gezeigt, wie Sie diese Bibliothek in Ihren eigenen Android-Projekten verwenden können.
In Erste Schritte mit RxJava 2 für Android haben wir uns angesehen, was RxJava ist und was Android-Entwickler zu bieten haben, bevor wir eine Hello World-App erstellen, die die drei Kernkomponenten von RxJava demonstriert: eine Beobachtbar, ein Beobachter, und ein Abo.
Im Tutorial Reaktive Programmieroperatoren in RxJava 2 haben wir untersucht, wie Sie komplexe Datentransformationen mit Operatoren durchführen und kombinieren können Operators und Planers, um das Multithreading auf Android endlich schmerzfrei zu machen.
Wir haben auch RxAndroid angesprochen, eine Bibliothek, die speziell für die Verwendung von RxJava in Android-Projekten entwickelt wurde. In RxAndroid gibt es jedoch noch viel mehr zu entdecken. In diesem Beitrag konzentriere ich mich daher ausschließlich auf die RxAndroid-Bibliotheksfamilie.
Ähnlich wie RxJava wurde RxAndroid in Version 2 einer umfassenden Überarbeitung unterzogen. Das RxAndroid-Team beschloss, die Bibliothek zu modularisieren und einen Großteil ihrer Funktionalität in dedizierte RxAndroid-Zusatzmodule umzuwandeln.
In diesem Artikel werde ich Ihnen zeigen, wie Sie einige der beliebtesten und leistungsfähigsten RxAndroid-Module einrichten und verwenden. Dazu gehört auch eine Bibliothek, die Listener, Handler und TextWatchers eine Sache der Vergangenheit, indem Sie Ihnen die Fähigkeit geben, damit umzugehen irgendein Android UI-Ereignis als Beobachtbar.
Und da Speicherverluste durch unvollständige Abonnements der größte Nachteil bei der Verwendung von RxJava in Ihren Android-Apps sind, zeige ich Ihnen auch, wie Sie ein RxAndroid-Modul verwenden, das den Abonnementprozess für Sie abwickelt. Am Ende dieses Artikels werden Sie wissen, wie Sie RxJava in jedem verwenden Aktivität oder Fragment, ohne das Risiko einer Begegnung einzugehen irgendein RxJava-bezogene Speicherlecks.
Das Reagieren auf UI-Ereignisse wie Taps, Swipes und Texteingabe ist ein grundlegender Bestandteil der Entwicklung nahezu aller Android-Apps. Die Handhabung von Android-UI-Ereignissen ist jedoch nicht besonders einfach.
In der Regel reagieren Sie auf Benutzeroberflächenereignisse mit einer Kombination aus Listenern und Handlern, TextWatchers, und möglicherweise andere Komponenten, abhängig von der Art der von Ihnen erstellten Benutzeroberfläche. Für jede dieser Komponenten müssen Sie eine beträchtliche Menge Boilerplate-Code schreiben. Darüber hinaus besteht keine Konsistenz in der Implementierung dieser verschiedenen Komponenten. Zum Beispiel handhaben Sie OnClick Ereignisse durch Implementierung eines OnClickListener:
Button button = (Button) findViewById (R.id.button); button.setOnClickListener (neuer View.OnClickListener () @Override public void onClick (View v) // Eine Arbeit ausführen //);
Dies ist jedoch völlig anders als bei der Implementierung eines TextWatcher:
final EditText name = (EditText) v.findViewById (R.ID.name); // Erstellen Sie einen TextWatcher und geben Sie an, dass dieser TextWatcher aufgerufen werden soll, wenn sich der Inhalt des EditText ändert. // name.addTextChangedListener (neuer TextWatcher () @Override public void beforeTextChanged (CharSequence, int start, int count, int after) @ Public void onTextChanged überschreiben (CharSequence s, int start, int before, int count) // Eine Arbeit ausführen // @Override public void afterTextChanged (Editable s) );
Diese mangelnde Konsistenz kann zu einer erheblichen Komplexität Ihres Codes führen. Und wenn Sie UI-Komponenten haben, die von der Ausgabe anderer UI-Komponenten abhängen, machen Sie sich bereit, um noch komplizierter zu werden! Sogar ein einfacher Anwendungsfall, wie zum Beispiel den Benutzer aufzufordern, seinen Namen in ein einzugeben Text bearbeiten So können Sie den Text, der später angezeigt wird, personalisieren TextViews-erfordert verschachtelte Rückrufe, deren Implementierung und Wartung bekanntermaßen schwierig ist. (Einige Leute bezeichnen verschachtelte Rückrufe als "Rückruf Hölle".)
Ein standardisierter Ansatz für die Handhabung von UI-Ereignissen kann den Code erheblich vereinfachen. RxBinding ist eine Bibliothek, die genau dies vorsieht, indem Bindungen bereitgestellt werden, die die Konvertierung von Android ermöglichen Aussicht Veranstaltung in eine Beobachtbar.
Sobald Sie ein Ansichtsereignis in eine konvertiert haben Beobachtbar, Die UI-Ereignisse werden als Datenströme ausgegeben, die Sie auf dieselbe Weise abonnieren können wie andere Beobachtbar.
Da wir bereits gesehen haben, wie Sie ein Klickereignis mit dem Android-Standard festhalten würden OnClickListener, Schauen wir uns an, wie Sie mit RxBinding die gleichen Ergebnisse erzielen würden:
import com.jakewharton.rxbinding.view.RxView;… Button button = (Button) findViewById (R.id.button); RxView.clicks (button) .subscribe (aVoid -> // Hier etwas Arbeit leisten //);
Dieser Ansatz ist nicht nur übersichtlicher, sondern auch eine Standardimplementierung, die Sie auf alle UI-Ereignisse anwenden können, die in Ihrer App auftreten. Die Erfassung von Texteingaben folgt beispielsweise demselben Muster wie das Erfassen von Klickereignissen:
RxTextView.textChanges (editText) .subscribe (charSequence -> // Hier einige Arbeit ausführen //);
So können Sie genau sehen, wie RxBinding den Code für die Benutzeroberfläche Ihrer App vereinfachen kann. Lassen Sie uns eine App erstellen, die einige dieser Bindungen in Aktion demonstriert. Ich werde auch eine hinzufügen Aussicht das hängt von der Ausgabe eines anderen ab Aussicht, um zu zeigen, wie RxBinding das Erstellen von Beziehungen zwischen Komponenten der Benutzeroberfläche vereinfacht.
Diese App besteht aus:
Taste das zeigt a Toast beim Tippen.Text bearbeiten das erkennt Textänderungen.Textvorschau das aktualisiert, um den Inhalt des anzuzeigen Text bearbeiten.Erstellen Sie ein Android Studio-Projekt mit den Einstellungen Ihrer Wahl und öffnen Sie dann Ihre Modulebene build.gradle Datei und fügen Sie die neueste Version der RxBinding-Bibliothek als Projektabhängigkeit hinzu. Um den Boilerplate-Code auf ein Minimum zu beschränken, werde ich auch Lambdas verwenden, also habe ich meinen aktualisiert build.gradle Datei zur Unterstützung dieser Java 8-Funktion:
plugin anwenden: 'com.android.application' android compileSdkVersion 25 buildToolsVersion "25.0.2" defaultConfig applicationId "com.jessicathornsby.myapplication" minSdkVersion 25 versionCode 1 versionName "1.0" testInstrumentationRunner "und" testInstrumentationRunner ". AndroidJUnitRunner "// Aktiviere die Jack-Toolchain // jackOptions enabled true buildTypes release minifyEnabled false proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro' // Setzt sourceCompatibility und targetCompatibility auf JavaVersion.VERSION_1_8 // compileOptions sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 Abhängigkeiten compileTree (Verzeichnis: 'libs', include: ['* .jar']) undroidTestCompile ('com.android.support.test.espresso) : espresso-core: 2.2.2 ', Gruppe ausschließen:' com.android.support ', Modul:' support-annotations ') // Füge die RxBinding-Kernbibliothek hinzu // compile' com.jakewharton.rxbinding: rxbinding: 0.4.0 'compile' com .android.support: appcompat-v7: 25.3.0 '// Vergessen Sie nicht, die Abhängigkeiten von RxJava und RxAndroid hinzuzufügen //' io.reactivex.rxjava2: rxandroid: 2.0.1 'kompilieren' io.reactivex.rxjava2: rxjava: 2.0.5 'testCompile' junit: junit: 4.12 ' Wenn Sie mit mehreren RxJava-Bibliotheken arbeiten, kann es vorkommen, dass Sie auf eine Doppelte Dateien, die in APK META-INF / ABHÄNGIGKEITEN kopiert wurden Fehlermeldung zur Kompilierzeit. Wenn dieser Fehler auftritt, können Sie diese doppelten Dateien unterdrücken, indem Sie der Modulebene Folgendes hinzufügen build.gradle Datei:
android packagingOptions // Verwenden Sie "exclude", um auf die bestimmte Datei (oder Dateien) zu verweisen, über die sich Android Studio beschwert, // "META-INF / rxjava.properties" ausschließen.
Synchronisieren Sie Ihre Gradle-Dateien und erstellen Sie ein Layout, das aus einem besteht Taste, ein Text bearbeiten, und ein Textvorschau:
Sehen wir uns nun an, wie Sie diese RxBinding verwenden, um die verschiedenen UI-Ereignisse zu erfassen, auf die unsere Anwendung reagieren muss. Als Erstes deklarieren Sie Ihre Importe und definieren die Hauptaktivität Klasse.
Paket com.jessicathornsby.myapplication; import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.widget.Button; import android.widget.EditText; import android.widget.TextView; import android.widget.Toast; // Importieren Sie die view.RxView-Klasse, sodass Sie RxView.clicks verwenden können. // import com.jakewharton.rxbinding.view.RxView; // Widget.RxTextView importieren, damit Sie RxTextView.textChanges verwenden können // import com.jakewharton.rxbinding.widget.RxTextView; public class MainActivity erweitert AppCompatActivity @Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); Button button = (Button) findViewById (R.id.button); TextView textView = (TextView) findViewById (R.id.textView); EditText editText = (EditText) findViewById (R.id.editText); // Code für die Bindungen geht hier // //… //
Jetzt können Sie Bindungen hinzufügen, um auf Ereignisse der Benutzeroberfläche zu reagieren. Das RxView.clicks Diese Methode wird zum Binden von Klickereignissen verwendet. Erstellen Sie eine Bindung, um einen Toast anzuzeigen, wenn Sie auf die Schaltfläche klicken:
RxView.clicks (button) .subscribe (aVoid -> Toast.makeText (MainActivity.this, "RxView.clicks", Toast.LENGTH_SHORT) .show (););
Als nächstes benutzen Sie die RxTextView.textChanges () Methode, um auf ein Textänderungsereignis zu reagieren, indem das Update aktualisiert wird Textvorschau mit dem Inhalt unseres Text bearbeiten.
RxTextView.textChanges (editText) .subscribe (charSequence -> textView.setText (charSequence););
Wenn Sie Ihre App ausführen, erhalten Sie einen Bildschirm wie den folgenden.
Installieren Sie Ihr Projekt auf einem physischen Android-Smartphone oder -Tablet oder einer kompatiblen AVD und verbringen Sie einige Zeit damit, mit den verschiedenen Elementen der Benutzeroberfläche zu interagieren. Ihre App sollte auf Klickereignisse und Texteingaben wie üblich reagieren - und dies alles ohne Listener, TextWatcher oder Callback!
Während die Kernbibliothek RxBinding Bindungen für alle Benutzeroberflächenelemente der Android-Standardplattform bereitstellt, gibt es auch RxBinding-Geschwistermodule, die Bindungen für die Ansichten bereitstellen, die Bestandteil der verschiedenen Unterstützungsbibliotheken von Android sind.
Wenn Sie Ihrem Projekt eine oder mehrere Unterstützungsbibliotheken hinzugefügt haben, möchten Sie in der Regel auch das entsprechende RxBinding-Modul hinzufügen.
Diese Geschwistermodule folgen einer einfachen Benennungskonvention, mit der die entsprechende Android-Unterstützungsbibliothek leicht identifiziert werden kann: Jedes Geschwistermodul nimmt einfach den Namen der Unterstützungsbibliothek an und ersetzt sie com.android mit com.jakewharton.rxbinding2: rxbinding.
com.jakewharton.rxbinding2 kompilieren: rxbinding-recyclerview-v7: 2.0.0 'compile 'com.jakewharton.rxbinding2: rxbinding-support-v4: 2.0.0'kompilieren Sie "com.jakewharton.rxbinding2: rxbinding-appcompat-v7: 2.0.0".comp.jakewharton.rxbinding2: rxbinding-design: 2.0.0kompilieren 'com.jakewharton.rxbinding2: rxbinding-recyclerview-v7: 2.0.0'compile 'com.jakewharton.rxbinding2: rxbinding-leanback-v17: 2.0.0'Wenn Sie Kotlin in Ihren Android-Projekten verwenden, ist für jedes RxBinding-Modul auch eine Kotlin-Version verfügbar. Um auf die Kotlin-Version zuzugreifen, fügen Sie sie einfach hinzu -Kotlin auf den Namen der Bibliothek, mit der Sie arbeiten möchten, also:
comp.jakewharton.rxbinding2: rxbinding-design: 2.0.0
Wird:
'com.jakewharton.rxbinding2: rxbinding-design-kotlin: 2.0.0' kompilieren
Sobald Sie eine konvertiert haben Aussicht Veranstaltung in eine Beobachtbar, Alle diese Ereignisse werden als Datenstrom ausgegeben. Wie wir bereits gesehen haben, können Sie diese Streams abonnieren und dann die Aufgabe ausführen, die Sie für das Auslösen eines bestimmten UI-Ereignisses benötigen, z Toast oder Aktualisierung a Textvorschau. Sie können jedoch auch jede der zahlreichen RxJava-Operatoren auf diesen beobachtbaren Stream anwenden und sogar mehrere Operatoren miteinander verketten, um komplexe Transformationen für Ihre UI-Ereignisse durchzuführen.
Es gibt viel zu viele Operatoren, die in einem einzigen Artikel besprochen werden können (und die offiziellen Dokumente listen ohnehin alle Operatoren auf). Wenn Sie jedoch mit Android-Benutzeroberflächenereignissen arbeiten, gibt es einige Operatoren, die besonders nützlich sein können.
debounce () OperatorErstens, wenn Sie befürchten, dass ein ungeduldiger Benutzer wiederholt auf ein Oberflächenelement tippen könnte, was Ihre App möglicherweise verwirrt, können Sie das verwenden debounce () Operator, um alle UI-Ereignisse herauszufiltern, die in schneller Folge ausgegeben werden.
Im folgenden Beispiel lege ich fest, dass diese Schaltfläche auf eine reagieren soll OnClick Ereignis nur, wenn seit dem letzten Klickereignis eine Lücke von mindestens 500 Millisekunden besteht:
RxView.clicks (Schaltfläche) .debounce (500, TimeUnit.MILLISECONDS) .subscribe (aVoid -> Toast.makeText (MainActivity.this, "RxView.clicks", Toast.LENGTH_SHORT) .show ();;
veröffentlichen() OperatorSie können auch die veröffentlichen() Operator, um mehrere Zuhörer an dieselbe Ansicht anzuhängen, etwas, das in Android traditionell schwer zu implementieren war.
Das veröffentlichen() Operator konvertiert einen Standard Beobachtbar in ein verbindbar beobachtbar. Während ein normales Observable anfängt, Elemente auszugeben, sobald der erste Beobachter es abonniert hat, wird ein verbindbares Observable nichts ausgeben, bis Sie es explizit anweisen, indem Sie das verbinden() Operator. Dadurch haben Sie die Möglichkeit, mehrere Beobachter zu abonnieren, ohne dass das Beobachtbare Elemente ausgibt, sobald das erste Abonnement stattfindet.
Nachdem Sie alle Ihre Abonnements erstellt haben, wenden Sie einfach das an verbinden() Der Operator und das Observable beginnen mit der Ausgabe von Daten an alle zugewiesenen Beobachter.
Wie wir in dieser Serie gesehen haben, kann RxJava ein leistungsfähiges Werkzeug sein, um reaktivere, interaktive Android-Anwendungen mit viel weniger Code zu erstellen, als Sie normalerweise benötigen, um mit Java allein die gleichen Ergebnisse zu erzielen. Die Verwendung von RxJava in Ihren Android-Anwendungen hat jedoch einen erheblichen Nachteil - das Potenzial für Speicherverluste durch unvollständige Abonnements.
Diese Speicherverluste treten auf, wenn das Android-System versucht, ein System zu zerstören Aktivität das enthält ein Laufen Beobachtbar. Da das Observable ausgeführt wird, hält sein Beobachter immer noch einen Verweis auf die Aktivität, und das System kann diese Aktivität daher nicht in der Müllabfuhr sammeln.
Da Android zerstört und neu erstellt Aktivitäts Bei jeder Änderung der Gerätekonfiguration erstellt Ihre App möglicherweise ein Duplikat Aktivität Der Benutzer wechselt jedes Mal zwischen Hoch- und Querformat sowie jedes Mal, wenn er die Tastatur des Geräts öffnet und schließt.
Diese Aktivitäten hängen sich im Hintergrund ab und werden möglicherweise nie mit Müll versorgt. Da es sich bei Activities um große Objekte handelt, kann dies schnell dazu führen ernst Probleme bei der Speicherverwaltung, zumal Android-Smartphones und -Tablets zu Beginn nur begrenzten Speicher haben. Die Kombination eines großen Speicherverlusts und eines begrenzten Speichers kann schnell zu einem Fehler führen Kein Speicher mehr Error.
RxJava-Speicherlecks können die Leistungsfähigkeit Ihrer Anwendung beeinträchtigen, aber es gibt eine RxAndroid-Bibliothek, mit der Sie RxJava in Ihrer App verwenden können, ohne sich um Speicherlecks kümmern zu müssen.
Die von Trello entwickelte RxLifecycle-Bibliothek bietet APIs zum Lebenszyklus-Management, mit denen Sie die Lebensdauer eines Produkts begrenzen können Beobachtbar zum Lebenszyklus eines Aktivität oder Fragment. Sobald diese Verbindung hergestellt ist, beendet RxLifecycle die Sequenz des Beobachtbaren als Reaktion auf Lebenszyklusereignisse, die in der zugewiesenen Aktivität oder dem Fragment des Beobachtbaren auftreten. Dies bedeutet, dass Sie ein Observable erstellen können, das automatisch beendet wird, wenn eine Aktivität oder ein Fragment zerstört wird.
Beachten Sie, dass wir reden beendend eine Sequenz und nicht abbestellen. Obwohl über RxLifecycle häufig im Zusammenhang mit der Verwaltung des Abonnement- / Abbestellungsprozesses gesprochen wird, technisch es kündigt einen Beobachter nicht ab. Stattdessen beendet die RxLifecycle-Bibliothek die beobachtbare Sequenz, indem sie entweder die onComplete () oder onError () Methode. Wenn Sie den Newsletter abbestellen, erhält der Beobachter keine Benachrichtigungen mehr von seinem beobachtbaren Objekt, auch wenn das beobachtbare Objekt noch Elemente ausgibt. Wenn Sie speziell ein Abbestellverhalten benötigen, müssen Sie dies selbst implementieren.
Öffnen Sie die Modulebene, um RxLifecycle in Ihren Android-Projekten zu verwenden build.gradle Datei und fügen Sie die neueste Version der RxLifeycle-Bibliothek sowie die RxLifecycle-Android-Bibliothek hinzu:
Abhängigkeiten … compile 'com.trello.rxlifecycle2: rxlifecycle: 2.0.1' compile 'com.trello.rxlifecycle2: rxlifecycle-android: 2.0.1'
Dann in der Aktivität oder Fragment Wenn Sie die Lebenszyklus-APIs der Bibliothek verwenden möchten, erweitern Sie die Option RxAktivität, RxAppCompatActivity oder RxFragment, und fügen Sie die entsprechende Importanweisung hinzu, zum Beispiel:
import com.trello.rxlifecycle2.components.support.RxAppCompatActivity;… public class MainActivity erweitert RxAppCompatActivity
Wenn es um das Binden geht Beobachtbar zum Lebenszyklus eines Aktivität oder Fragment, Sie können entweder das Lebenszyklusereignis angeben, bei dem das Observable beendet werden soll, oder Sie können die RxLifecycle-Bibliothek entscheiden lassen, wann die beobachtbare Sequenz beendet werden soll.
Standardmäßig beendet RxLifecycle ein beobachtbares Ereignis im ergänzenden Lebenszyklusereignis bis zu dem Ereignis, in dem dieses Abonnement stattgefunden hat. Wenn Sie also ein beobachtbares Element während Ihrer Aktivitäten abonnieren, wird RxLifecycle beendet onCreate () Methode, dann beendet RxLifecycle die beobachtbare Sequenz während dieser Aktivitäten onDestroy () Methode. Wenn Sie sich während eines Fragment's onAttach () Methode, dann beendet RxLifecycle diese Sequenz in der onDetach () Methode.
Sie können diese Entscheidung mit RxLifecycle überlassen RxLifecycleAndroid.bindActivity:
BeobachtbarmyObservable = Observable.range (0, 25);… @Override public void onResume () super.onResume (); myObservable .compose (RxLifecycleAndroid.bindActivity (Lebenszyklus)) .subscribe ();
Alternativ können Sie das Lebenszyklusereignis angeben, bei dem RxLifecycle ein Ereignis beenden soll Beobachtbar Reihenfolge verwenden RxLifecycle.bindUntilEvent.
Hier möchte ich angeben, dass die beobachtbare Sequenz in beendet werden soll onDestroy ():
@Override public void onResume () super.onResume (); myObservable .compose (RxLifecycle.bindUntilEvent (Lebenszyklus, ActivityEvent.DESTROY)) .subscribe ();
Die letzte Bibliothek, die wir uns anschauen werden, ist RxPermissions, die Ihnen bei der Verwendung von RxJava mit dem neuen in Android 6.0 eingeführten Berechtigungsmodell helfen soll. Mit dieser Bibliothek können Sie auch eine Berechtigungsanforderung ausgeben und das Berechtigungsergebnis am selben Speicherort abwickeln, anstatt die Berechtigung an einem Ort anzufordern und dann die Ergebnisse separat zu behandeln Activity.onRequestPermissionsResult ().
Beginnen Sie mit dem Hinzufügen der RxPermissions-Bibliothek zu Ihrem build.gradle Datei:
'com.tbruyelle.rxpermissions2: rxpermissions: 0.9.3@aar' kompilieren
Dann erstellen Sie eine RxPermissions-Instanz:
RxPermissions rxPermissions = neue RxPermissions (this);
Sie können dann mit der folgenden Formel in der RxPermissions-Bibliothek Berechtigungsanfragen stellen:
rxPermissions.request (Manifest.permission.READ_CONTACTS) .subscribe (bewilligt -> if (bewilligt) // Die Berechtigung wurde erteilt // else // Die Berechtigung wurde abgelehnt //;
Woher Sie geben Ihre Berechtigungsanfrage aus, da das Hosting immer eine Chance hat Aktivität wird möglicherweise gelöscht und dann erneut erstellt, während der Berechtigungsdialogfeld angezeigt wird, normalerweise aufgrund einer Konfigurationsänderung, z. B. wenn der Benutzer zwischen Hoch- und Querformat wechselt. Wenn dies der Fall ist, wird Ihr Abonnement möglicherweise nicht erneut erstellt. Dies bedeutet, dass Sie die Beobachtungsfunktion für RxPermissions nicht abonniert haben und keine Antwort des Benutzers auf das Dialogfeld für die Berechtigungsanforderung erhalten. Um zu gewährleisten, dass Ihre Anwendung die Antwort des Benutzers erhält, immer Rufen Sie Ihre Anfrage während einer Initialisierungsphase auf, wie z Activity.onCreate (), Activity.onResume (), oder View.onFinishInflate ().
Es ist nicht ungewöhnlich, dass Funktionen mehrere Berechtigungen erfordern. Wenn Sie beispielsweise eine SMS-Nachricht senden, muss Ihre App in der Regel über eine SMS verfügen SMS SENDEN und READ_CONTACTS Berechtigungen. Die RxPermissions-Bibliothek bietet eine übersichtliche Methode zum Ausgeben mehrerer Berechtigungsanforderungen und zum Kombinieren der Antworten des Benutzers zu einer einzigen falsch (eine oder mehrere Berechtigungen wurden abgelehnt) oder wahr (alle Berechtigungen wurden erteilt) Antwort, auf die Sie dann entsprechend reagieren können.
RxPermissions.getInstance (this) .request (Manifest.permission.SEND_SMS, Manifest.permission.READ_CONTACTS) .subscribe (bewilligt -> wenn (gewährt) // Alle Berechtigungen wurden erteilt // else // Eine oder mehrere Berechtigungen wurde abgelehnt// );
Normalerweise möchten Sie eine Berechtigungsanfrage als Reaktion auf ein UI-Ereignis auslösen, z. B. wenn der Benutzer auf ein Menüelement oder eine Schaltfläche tippt. RxPermissions und RxBiding sind also zwei Bibliotheken, die besonders gut zusammenarbeiten.
Wenn Sie das UI-Ereignis als beobachtbar behandeln und die Berechtigungsanforderung über RxPermissions ausführen, können Sie mit wenigen Codezeilen eine Menge Arbeit erledigen:
RxView.clicks (findViewById (R.id.enableBluetooth)) .compose (RxPermissions.getInstance (this) .ensure (Manifest.permission.BLUETOOTH_ADMIN)) .subscribe (grant -> // Die Schaltfläche 'enableBluetooth' wurde aktiviert / /);
Nachdem Sie diesen Artikel gelesen haben, haben Sie einige Ideen, wie Sie eine Menge Boilerplate-Code aus Ihren Android-Apps ausschneiden können, indem Sie RxJava verwenden, um alle UI-Ereignisse Ihrer Anwendung zu verarbeiten und Ihre Berechtigungsanfragen über RxPermissions ausgeben. Wir haben auch untersucht, wie Sie RxJava in jedem Android verwenden können Aktivität oder Fragment, ohne sich um die Speicherverluste kümmern zu müssen, die durch unvollständige Abonnements verursacht werden können.
Wir haben einige der beliebtesten und nützlichsten RxJava- und RxAndroid-Bibliotheken in dieser Serie untersucht. Wenn Sie wissen möchten, was RxJava Android-Entwicklern sonst noch bietet, sollten Sie sich einige der vielen anderen RxAndroid-Bibliotheken ansehen. Eine umfassende Liste zusätzlicher RxAndroid-Bibliotheken finden Sie unter GitHub.
In der Zwischenzeit können Sie einige unserer anderen Android-Entwicklungsbeiträge hier auf Envato Tuts lesen+!
