Comme vous le savez peut-être, dans l'écosystème réactif, nous avons une Observable qui émet des données et un Observateur qui s'abonne (est notifié) de cette émission Observable, rien d'étrange à la façon dont fonctionne ce que l'on appelle le modèle Observer. Un Observable "crie" quelque chose, l'Observateur est notifié que l'Observable crie quelque chose à un moment donné.
Pensez à LiveData comme un Observable qui vous permet de gérer les Observateurs qui se trouvent dans une active l'état. En d'autres termes LiveData est un simple Observable mais aussi s'occupe du cycle de vie.
Mais voyons les deux cas de code que vous demandez :
A) Données en direct
B) RXJava
A) Il s'agit d'une implémentation de base de LiveData
1) vous instanciez habituellement LiveData dans le ViewModel pour maintenir le changement d'orientation (vous pouvez avoir LiveData qui est en lecture seule, ou MutableLiveData qui est en écriture, donc vous exposez habituellement à l'extérieur de la classe LiveData)
2) dans la OnCreate de la méthode Principal Activité (pas le ViewModel) vous "souscrivez" un objet Observer (généralement par une méthode onChanged)
3) vous lancez la méthode observée pour établir le lien
D'abord le ViewModel (possède la logique d'entreprise)
class ViewModel : ViewModel() { //Point 1
var liveData: MutableLiveData<Int> = MutableLiveData()
}
Et c'est le MainActivity ( aussi stupide que possible )
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)
ViewModelProvider.observe(this, Observer {//Points 2 and 3
//what you want to observe
})
}
}
}
B) Voici l'implémentation de base de RXJava
1) vous déclarez un Observable
2) vous déclarez un Observateur
3) vous abonnez l'Observable avec l'Observateur
Observable.just(1, 2, 3, 4, 5, 6) // Point 1
.subscribe(new Subscriber() { //Points 2 & 3
@Override
public void onCompleted() {
System.out.println("Complete!");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Double value) {
System.out.println("onNext: " + value);
}
});
En particulier LiveData est utilisé avec Lifecycle et souvent avec ViewModel (comme nous l'avons vu) des composants d'architecture. En effet, lorsque LiveData est combinée avec un ViewModel vous permet pour tenir à jour en temps réel chaque changement dans l'observateur, afin que les événements soient gérés en temps réel là où cela est nécessaire. Pour utiliser LiveData est fortement recommandé pour connaître le concept de cycle de vie et les objets relatifs Propriétaire de LifeCycle/LifeCycle Je vous suggère également de jeter un coup d'œil à Transformations si vous voulez mettre en œuvre LiveData dans des scénarios de la vie réelle. Vous trouverez ici quelques cas d'utilisation de la grande commonsware .
Pour conclure En gros, LiveData est une version simplifiée RXJava RXJava, un moyen élégant d'observer les changements dans plusieurs composants sans créer de règles de dépendance explicites entre les composants, ce qui permet de tester plus facilement le code et de le rendre beaucoup plus lisible. RXJava, vous permet de faire les choses de LiveData et bien plus encore. Grâce aux fonctionnalités étendues de RXJava, vous pouvez à la fois utiliser LiveData pour des cas simples ou exploiter toute la puissance de RXJava en continuant à utiliser des composants de l'architecture Android comme le composant ViewModel bien sûr, cela signifie que RXJava peut être beaucoup plus complexe, il suffit de penser a des centaines d'opérateurs au lieu de SwitchMap et Map of LiveData(pour le moment).
RXJava version 2 est une bibliothèque qui a révolutionné le paradigme orienté objet, en ajoutant une manière dite fonctionnelle de gérer le flux du programme.
8 votes
Vous avez trouvé une bonne raison ? Je me pose la même question...