web-dev-qa-db-fra.com

Quand devrions-nous utiliser le compilateur Android.Arch.lifecycle: (ou Android.Arch.lifecycle: common-Java8)?

Actuellement, nous utilisons LiveData, ViewModel et Room dans notre projet.

Nous utilisons Java 8.

Nous utilisons ce qui suit dans build.gradle

// ViewModel and LiveData
implementation "Android.Arch.lifecycle:extensions:1.1.1"

// Room (use 1.1.0-beta1 for latest beta)
implementation "Android.Arch.persistence.room:runtime:1.0.0"
annotationProcessor "Android.Arch.persistence.room:compiler:1.0.0"

Je me demandais, quand devons-nous utiliser

annotationProcessor "Android.Arch.lifecycle:compiler:1.1.1"

(Ou implementation "Android.Arch.lifecycle:common-Java8:1.1.1" puisque nous utilisons Java 8 ?!)

Actuellement, notre code fonctionne correctement, sans utiliser lifecycle:compiler ou lifecycle:common-Java8.

androidandroid-architecture-components
21
Cheok Yan Cheng

quand devons-nous utiliser annotationProcessor "Android.Arch.lifecycle:compiler:1.1.1"

AFAIK, cela n'est nécessaire que si vous avez des annotations liées au cycle de vie dans votre code, en particulier @OnLifecycleEvent.

Ou implémentation "Android.Arch.lifecycle: common-Java8: 1.1.1" puisque nous utilisons Java 8?

Même chose. L'état des documents "Si votre application utilise Java 8, nous vous recommandons d'utiliser cette bibliothèque au lieu de Android.Arch.lifecycle:compiler. "

11
CommonsWare

Android.Arch.lifecycle: compilateur: 1.1.1 est utilisé lorsque vous écrivez une classe personnalisée implémentant LifecycleObserver

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        ...
    }
}

extrait de https://developer.Android.com/topic/libraries/architecture/lifecycle.html

3
Samuel Eminet

Vos options

Autant que je sache, vous avez 3 options:

LifecycleObserver

C'est une interface de marqueur, elle n'a aucune méthode. Votre classe l'implémentera, puis vous définissez un groupe de @OnLifecycleEvent méthodes selon vos besoins.

L'exécution du cycle de vie fera l'une des 2 choses suivantes:

  • Utilisez la réflexion pour rechercher les méthodes annotées,
  • ou utilisez des adaptateurs générés si vous avez activé le lifecycle-compiler processeur d'annotation.

Cette interface fait partie du lifecycle-common bibliothèque.

LifecycleEventObserver

Il fournit une méthode unique

void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);

qui sera appelée au lieu de toutes les méthodes annotées.

Cette interface fait partie du lifecycle-common bibliothèque.

DefaultLifecycleObserver

Il fournit une interface avec plusieurs méthodes vides:

default void onCreate(@NonNull LifecycleOwner owner) {}
default void onStart(@NonNull LifecycleOwner owner) {}
default void onResume(@NonNull LifecycleOwner owner) {}
default void onPause(@NonNull LifecycleOwner owner) {}
default void onStop(@NonNull LifecycleOwner owner) {}
default void onDestroy(@NonNull LifecycleOwner owner) {}

Votre classe implémentera cette interface et vous pourrez choisir les méthodes à implémenter.

Cette interface fait partie du lifecycle-common-Java8 bibliothèque. Les interfaces avec certaines méthodes implémentées (méthodes par défaut) sont prises en charge depuis Java 8. Si votre projet a activé Java 8 fonctionnalités du langage vous peut l'utiliser.

Qu'en faire

LifecycleEventObserver et DefaultLifecycleObserver ajoutent des méthodes à votre classe, ce n'est peut-être pas ce que vous voulez. Ce n'est certainement pas ce que j'aime.

Je m'attends à ce que vous créiez une méthode avec un nom sémantiquement précis et que vous indiquiez au framework Lifecycle uniquement quand il devrait l'appeler. Ainsi:

@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void startListening();

Cela ne pollue pas votre classe avec des méthodes supplémentaires. Et vous pouvez utiliser le processeur d'annotation pour le rendre plus rapide au moment de l'exécution.

Je trouve cette déclaration de Notes de mise à jour du cycle de vie inexacte:

annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-Java8:$lifecycle_version"

Le compilateur génère un adaptateur pour que vous n'ayez pas à modifier l'interface de votre classe. Cela fonctionne totalement différemment de DefaultLifecycleObserver.

0
Eugen Pechanec

Déclaration de dépendance du processeur d'annotation du cycle de vie pour Java 8 doit être comme suit:

implementation "androidx.lifecycle:lifecycle-common-Java8:$lifecycle_version"

Au lieu de:

kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
0
Benny