Share
Comme d'habitude, les Google I / O de cette année ont vu de nombreuses annonces liées à Android.
Dans cette série de conseils rapides, nous allons examiner de plus près certaines des mises à jour logicielles et des nouvelles versions sur lesquelles vous pouvez mettre la main. aujourd'hui.
Dans ce premier article, nous allons examiner une collection de bibliothèques visant à simplifier la gestion du cycle de vie en vous permettant de créer des composants sensibles au cycle de vie qui permettent de suivre et de réagir automatiquement aux événements de cycle de vie. Je vous présenterai également une brève introduction à deux autres composants conçus pour être utilisés avec ces nouveaux composants sensibles au cycle de vie: LiveData et Room..
Respecter le cycle de vie de votre Activitéle sable Fragments est crucial créer une application réussie. Si vous comprenez mal ces principes fondamentaux, vous allez vous retrouver avec des fuites de mémoire qui peuvent entraîner un décalage de votre application, voire un crash..
Un autre problème récurrent que vous pouvez rencontrer avec la gestion du cycle de vie consiste à tenter de mettre à jour l'interface utilisateur de votre application lorsque l'activité ou le fragment n'est pas à l'état valide. Par exemple, si un Activité reçoit un rappel après son arrêt, il est fort probable que votre application va se bloquer.
Pour vous aider à éviter tous les maux de tête liés à la gestion du cycle de vie, Google a annoncé un nouvel ensemble de composants sensibles au cycle de vie qui peuvent suivre le cycle de vie d'une activité ou d'un fragment et ajuster leur comportement en conséquence..
Vous pouvez aujourd'hui accéder à ces composants d'architecture Android via le référentiel Maven de Google. Cependant, ils sont toujours en alpha, vous devez donc vous attendre à des changements radicaux avant la version 1.0..
En particulier, le Fragment et AppCompatActivity les classes actuellement ne peuvent pas mettre en œuvre la nouvelle Cycle de vie interface. Vous aurez besoin d'utiliser le temporaire Cycle de vieActivité et Cycle de vieFragment classes jusqu’à ce que les composants d’architecture Android atteignent leur version 1.0. Ces classes seront obsolètes dès que les fragments et les activités d'Android auront été mis à jour pour prendre en charge les composants du cycle de vie..
Pour commencer à expérimenter ces composants, vous devez ajouter le référentiel Google Maven à votre projet. build.gradle fichier:
allprojects repositories jcenter () // Ajouter le référentiel Google Maven // maven url 'https://maven.google.com'
Ensuite, ouvrez votre module build.gradle fichier, et ajoutez ce qui suit:
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 "
Il existe quelques composants d'architecture Android, mais dans cet article, nous allons nous concentrer sur les deux suivants:
Accentsconagua
Cycle de vie: Ceci est quelque chose qui a un cycle de vie, comme un Activité ou Fragment.LifecycleObserver: Il s'agit d'une classe qui peut surveiller l'état du cycle de vie d'un composant via des méthodes annotées. Ces méthodes sont appelées chaque fois que le composant associé entre dans l'état de cycle de vie correspondant..En déplaçant le code qui surveille et réagit aux événements du cycle de vie dans un environnement distinct LifecycleObserver, vous pouvez empêcher votre activité ou les méthodes liées au cycle de vie de votre fragment (telles que onStart et onStop) pour éviter tout problème, rendant votre code beaucoup plus lisible par l'homme.
Dans l'exemple suivant, nous implémentons LifecycleObserver, puis en utilisant le @OnLifeCycleEvent réagir à divers événements du cycle de vie:
importer android.arch.lifecycle.Lifecycle; importer android.arch.lifecycle.LifecycleObserver; import android.arch.lifecycle.OnLifecycleEvent; La classe publique SecondActivity implémente LifecycleObserver … lifecycle.addObserver (this); @OnLifecycleEvent (Lifecycle.Event.ON_START) void start () // Lorsque l'activité passe dans l'état ON_START, effectuez une opération // @OnLifecycleEvent (Lifecycle.Event.ON_STOP) void stop () // lorsque l'activité est entrée un état ON_STOP, faites quelque chose // // lorsque l'activité est détruite, annulez l'inscription de LifecycleObserver // @OnLifecycleEvent (Lifecycle.Event.ON_DESTORY) void cleanup () lifecycle.removeObserver (this);
Ensuite, dans le Activité vous voulez surveiller, étendre Cycle de vieActivité pour avoir accès au LifecycleObserver information:
Classe publique MainActivity: extension LifecycleActivity
De nombreuses opérations ne peuvent être effectuées que lorsqu'un fragment ou une activité est dans un état spécifique. Vous pouvez utiliser cycle de vie.getState pour vérifier rapidement et facilement l'état actuel du composant, puis n'exécutez l'action que si le composant est dans le bon état:
if (lifecycle.getState (). isAtLeast (STARTED))
Données en directDonnées en direct est un détenteur de données observable qui expose un flux d'événements que vous pouvez observer.
La principale différence entre Données en direct et d'autres observables, tels que RxJava, est que Données en direct est conscient du cycle de vie Android. Données en direct respecte l'état du cycle de vie de vos activités, fragments et services et gérera les abonnements pour vous.
Surtout, si le cycle de vie d'un observateur est inactif, l'observateur ne sera pas informé des modifications apportées au Données en direct, prévention des pannes d'application pouvant survenir lorsque vous essayez de placer les mises à jour sur des composants arrêtés.
Utiliser Données en direct, vous devez juste dire à votre Activité que vous souhaitez observer certaines données au cours du cycle de vie:
public class MyActivity étend LifecycleActivity public void onCreate (Bundle savedState) LiveDatadonnées d'utilisateur; // Récupère les données utilisateur quelque part // userData.observe (this, user -> );
Dès que l'activité commence, l'observation commence. Données en direct, et votre observateur recevra une mise à jour chaque fois que la valeur de cette Données en direct changements. Si la Activité est détruit, l'abonnement sera automatiquement supprimé.
Si un Activité est arrêté en raison d'un changement de configuration, la nouvelle instance de cette Activité recevra la dernière valeur disponible du Données en direct.
Données en direct partage certaines similitudes avec RxJava, mais le mot officiel de Google I / O est que si vous connaissez RxJava, vous devriez alors commencer vos projets Android avec Données en direct, comme il est conçu pour être simple, rapide et léger, et s'intègre bien au cadre Android. Vous pouvez ensuite ajouter des fonctionnalités RxJava si vous avez besoin de fonctionnalités de programmation réactive supplémentaires.
Si vous voulez utiliser Données en direct avec la bibliothèque RxJava 2, puis ouvrez votre module build.gradle déposer et ajouter ce qui suit:
compile "android.arch.lifecycle: réactivestreams: 1.0.0-alpha1"
Vous pourrez alors utiliser les méthodes suivantes:
toPublisher: Adapte le Données en direct streamer vers un flux réactif Éditeur.
statique publiqueÉditeur toPublisher (cycle de vie final de LifecycleOwner, final LiveData données en direct)
dePublisher: Crée un observable Données en direct flux depuis un éditeur ReactiveStreams.
statique publiqueDonnées en direct fromPublisher (éditeur final éditeur)
Bien que la structure Android prenne en charge le travail avec le contenu SQL brut, la mise en œuvre de ces API est relativement simple et prend beaucoup de temps..
La nouvelle bibliothèque Room de Google promet de résumer certains des détails d'implémentation sous-jacents de l'utilisation de tables et de requêtes SQL brutes. Cela devrait également aider à réduire la quantité de code standard que vous devez écrire afin de convertir les requêtes SQL en objets de données Java. Migration classe que vous pouvez utiliser pour mettre à jour votre application sans perdre les données de l'utilisateur.
Pour utiliser Room, ouvrez votre niveau de module build.gradle déposer et ajouter ce qui suit au les dépendances section:
compiler "android.arch.persistence.room:runtime:1.0.0-alpha1" annotationProcessor "android.arch.persistence.room:compiler:1.0.0-alpha1"
Lors de l'exécution de requêtes, vous souhaiterez généralement que votre interface utilisateur se mette à jour automatiquement chaque fois que les données sont modifiées. avec Room, vous pouvez y parvenir en utilisant un type de valeur de retour de Données en direct.
Enfin, si vous utilisez RxJava, vos requêtes de salle peuvent également renvoyer les réponses de RxJava 2. Éditeur et Fluide objets. Pour utiliser RxJava avec Room, vous devez ouvrir votre module au niveau du module. build.gradle déposer et ajouter ce qui suit au les dépendances section:
compiler 'android.arch.persistence.room:rxjava2:1.0.0-alpha1'
Dans cette astuce, je vous ai montré comment gérer le cycle de vie Android, à l'aide de LifecycleOwner et de LifecycleObserver, et vous ai présenté deux composants supplémentaires que vous souhaiterez peut-être utiliser parallèlement au projet Lifecycle..
Dans le prochain conseil, nous allons examiner les projets de Google visant à fusionner les composants de l'interface utilisateur Android Wear avec la bibliothèque de support Android, ainsi que certains ajouts aux complications liées à Android Wear..
En attendant, consultez nos autres tutoriels et nos cours vidéo sur le développement d'applications Android.!
