Google I / O 2017 Suite: Erstellen lebenszyklussensitiver Komponenten

Wie üblich gab es in diesem Jahr bei Google I / O viele Ankündigungen im Zusammenhang mit Android.

In dieser Reihe von Kurztipps werden wir uns einige der Software-Updates und Neuerscheinungen genauer ansehen, die Sie in die Hände bekommen können. heute.

In diesem ersten Artikel werfen wir einen Blick auf eine Sammlung von Bibliotheken, mit denen das Lebenszyklusmanagement entlastet werden soll. Auf diese Weise können Sie lebenszyklussensitive Komponenten erstellen, die Lebenszyklusereignisse automatisch verfolgen und darauf reagieren können. Ich werde auch eine kurze Einführung in zwei andere Komponenten geben, die für die Verwendung mit diesen neuen lebenszyklussensitiven Komponenten entwickelt wurden: LiveData und Room.

LifecycleOwner und LifecycleObserver

Respektieren Sie den Lebenszyklus Ihres Activityder Sand Fragmentes ist entscheidend um eine erfolgreiche Anwendung zu erstellen. Wenn Sie diese Grundlagen nicht erfüllen, kommt es zu Speicherverlusten, die dazu führen, dass Ihre Anwendung verzögert oder sogar abstürzt.

Ein weiteres häufiges Problem bei der Lebenszyklusverwaltung ist der Versuch, die Benutzeroberfläche Ihrer App zu aktualisieren, wenn sich die Aktivität oder das Fragment nicht in einem gültigen Zustand befindet. Zum Beispiel, wenn a Activity erhält nach dem Herunterfahren einen Rückruf, sodass die Wahrscheinlichkeit groß ist, dass Ihre App abstürzt.

Um Ihnen zu helfen, alle Probleme des Lebenszyklusmanagements zu vermeiden, hat Google eine Reihe neuer lebenszyklussensitiver Komponenten angekündigt, mit denen Sie den Lebenszyklus einer Aktivität oder eines Fragments verfolgen und anpassen können ihr Verhalten entsprechend.

Sie können heute über das Maven-Repository von Google auf diese Android-Architekturkomponenten zugreifen. Sie befinden sich jedoch noch in der Alpha-Version, sodass Sie vor Version 1.0 mit einigen wichtigen Änderungen rechnen sollten.

Insbesondere die Fragment und AppCompatActivity Klassen können das neue derzeit nicht implementieren LifecycleOwner Schnittstelle. Sie müssen die temporäre verwenden LifecycleActivity und LifecycleFragment Klassen, bis die Komponenten der Android-Architektur die Version 1.0 erreichen. Diese Klassen sind veraltet, sobald Android-Fragmente und -Aktivitäten aktualisiert wurden, um Lebenszykluskomponenten zu unterstützen.

Um mit diesen Komponenten zu experimentieren, müssen Sie Ihrem Projekt das Google Maven-Repository hinzufügen. build.gradle Datei:

allprojects {
   repositories {
       jcenter() 
       
//Add the Google Maven repository//

       maven { url 'https://maven.google.com' }
   }
}

Öffnen Sie dann Ihr Modul auf der Ebene build.gradle Datei und fügen Sie Folgendes hinzu:

dependencies {

  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile "android.arch.lifecycle:runtime:1.0.0-alpha1"
  compile "android.arch.lifecycle:extensions:1.0.0-alpha1"
  annotationProcessor "android.arch.lifecycle:compiler:1.0.0-alpha1"

Es gibt einige Komponenten der Android-Architektur, aber in diesem Artikel konzentrieren wir uns nur auf die folgenden zwei:

• LifecycleOwner:: Es ist etwas, das einen Lebenszyklus hat, wie ein Activity oder Fragment.
• LifecycleObserver:: Dies ist eine Klasse, die den Lebenszyklusstatus einer Komponente mithilfe von mit Anmerkungen versehenen Methoden überwachen kann. Diese Methoden werden immer dann aufgerufen, wenn die zugehörige Komponente in den entsprechenden Lebenszykluszustand wechselt.

Durch Verschieben des Codes, der Lebenszyklusereignisse überwacht und auf diese reagiert, in einen anderen LifecycleObserverkönnen Sie Ihre Aktivitäten oder Methoden im Zusammenhang mit dem Fragmentlebenszyklus verhindern (z onStart und onStop), um außer Kontrolle zu geraten und Ihren Code viel besser lesbar zu machen.

Im folgenden Beispiel implementieren wir LifecycleObserver, dann mit dem @OnLifeCycleEvent auf verschiedene Lebenszyklusereignisse reagieren:

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
 
public class SecondActivity implements LifecycleObserver {
...
...
...
          lifecycle.addObserver(this);

      }
      @OnLifecycleEvent(Lifecycle.Event.ON_START) void start()  {

//When the Activity enters an ON_START state, do something//

      }

      @OnLifecycleEvent(Lifecycle.Event.ON_STOP) void stop()  {

//When the Activity enters an ON_STOP state, do something//

      }

//When the Activity is destroyed, unregister the LifecycleObserver//

      @OnLifecycleEvent(Lifecycle.Event.ON_DESTORY) void cleanup()  {

          lifecycle.removeObserver(this);

      }
  }

Dann in der Activity Sie möchten überwachen, erweitern LifecycleActivity Zugang zu haben LifecycleObserver Information:

public class MainActivity extends LifecycleActivity {

Viele Operationen können nur ausgeführt werden, wenn sich ein Fragment oder eine Aktivität in einem bestimmten Zustand befindet. Sie können verwenden lifecycle.getState Um den aktuellen Status der Komponente schnell und einfach zu überprüfen, führen Sie die Aktion nur aus, wenn sich die Komponente im richtigen Status befindet:

if (lifecycle.getState().isAtLeast(STARTED)) {

LiveData

LiveData ist ein beobachtbarer Datenspeicher, der einen Strom von Ereignissen verfügbar macht, die Sie beobachten können.

Der Hauptunterschied zwischen LiveData und andere Observable wie RxJava sind das LiveData ist sich des Android-Lebenszyklus bewusst. LiveData respektiert den Lebenszyklusstatus Ihrer Aktivitäten, Shards und Services und verwaltet Abonnements für Sie.

Wenn der Lebenszyklus eines Beobachters inaktiv ist, wird der Beobachter nicht über Änderungen am informiert LiveDataDies verhindert Anwendungsabstürze, die auftreten können, wenn versucht wird, Updates auf gestoppte Komponenten zu übertragen.

Verwenden LiveData, du musst es dir nur sagen Activity dass Sie bestimmte Daten während des Lebenszyklus beobachten möchten:

public class MyActivity extends LifecycleActivity {
  public void onCreate(Bundle savedState)  {
       LiveData userData;

//Get user data from somewhere//

       userData.observe(this, user ->  {

       });
    }
 }

Von Beginn der Aktivität an wird er beginnen, das zu beobachten LiveData, und Ihr Beobachter erhält ein Update, sobald der Wert davon LiveData Änderungen. Wenn die Activity Wird zerstört, wird das Abonnement automatisch gelöscht.

Und ein Activity wird aufgrund einer Konfigurationsänderung gestoppt, dann die neue Instanz davon Activity erhält den letzten verfügbaren Wert von LiveData.

LiveData hat einige Ähnlichkeiten mit RxJava, aber das offizielle Wort von Google I / O lautet: Wenn Sie mit RxJava vertraut sind, sollten Sie Ihre Android-Projekte mit starten LiveData, weil es einfach, schnell und leicht gestaltet ist und sich gut in das Android-Framework integrieren lässt. Sie können dann die RxJava-Funktionalität hinzufügen, wenn Sie zusätzliche reaktive Programmierfunktionen benötigen.

Wenn Sie verwenden möchten LiveData Öffnen Sie dann mit der RxJava 2-Bibliothek Ihr Modul auf der Ebene build.gradle Datei und fügen Sie Folgendes hinzu:

compile "android.arch.lifecycle:reactivestreams:1.0.0-alpha1" 

Sie können dann die folgenden Methoden verwenden:

• toPublisher:: Passen Sie die LiveData stream vers un ReactiveStreams Publisher.

public static  Publisher toPublisher(
      final LifecycleOwner lifecycle, final LiveData liveData) { 

• fromPublisher:: Erstellen Sie eine beobachtbare LiveData Feed aus einem ReactiveStreams-Editor.

public static  LiveData fromPublisher(final Publisher publisher)

Die Raumbibliothek

Obwohl das Android-Framework eine integrierte Unterstützung für die Arbeit mit SQL-Rohinhalten bietet, sind diese APIs recht einfach und benötigen Zeit für die Implementierung.

Google ist neu Raumbibliothek verspricht, einige der zugrunde liegenden Implementierungsdetails der Arbeit mit unformatierten SQL-Tabellen und Abfragen zu abstrahieren. Es sollte auch dazu beitragen, die Menge an Standardcode zu reduzieren, die Sie schreiben müssen, um SQL-Abfragen in Java-Datenobjekte zu konvertieren, und es enthält a Migration Klasse, mit der Sie Ihre App aktualisieren können, ohne Benutzerdaten zu verlieren.

Um Room zu verwenden, öffnen Sie Ihr Modul auf der Ebene build.gradle Datei und fügen Sie Folgendes hinzu dependencies Sektion:

compile "android.arch.persistence.room:runtime:1.0.0-alpha1"
annotationProcessor "android.arch.persistence.room:compiler:1.0.0-alpha1" 

Wenn Sie Abfragen ausführen, möchten Sie im Allgemeinen, dass Ihre Benutzeroberfläche automatisch aktualisiert wird, wenn sich die Daten ändern. Mit Room können Sie dies erreichen, indem Sie einen Rückgabewerttyp von verwenden LiveData.

Wenn Sie RxJava verwenden, geben Ihre Raumanforderungen möglicherweise auch RxJava 2 zurück Publisher und Flowable Objekte. Um RxJava mit Room verwenden zu können, müssen Sie Ihr Modul auf der Ebene öffnen build.gradle Datei und fügen Sie Folgendes hinzu dependencies Sektion:

compile 'android.arch.persistence.room:rxjava2:1.0.0-alpha1' 

Fazit

In diesem kurzen Tipp habe ich Ihnen gezeigt, wie Sie den Android-Lebenszyklus mithilfe von LifecycleOwner und LifecycleObserver verwalten, und zwei zusätzliche Komponenten vorgestellt, die Sie möglicherweise neben dem Lifecycle-Projekt verwenden möchten.

Im nächsten Tipp werden wir uns mit Googles Plänen befassen, Android Wear UI-Komponenten mit der Android Support Library zusammenzuführen, sowie einige Ergänzungen zu Android Wear-Komplikationen.

In der Zwischenzeit können Sie einige unserer anderen Tutorials und Videolektionen zur Entwicklung von Android-Apps lesen!