Comme vous le savez peut-être dans l'écosystème réactif, nous avons un observable qui émet des données et un observateur qui s'abonne (se fait notifier) de cette émission observable, rien d'étrange n'est comment fonctionne le soi-disant modèle d'observateur. Un observable «crie» quelque chose, l'observateur est notifié que l'observable crie quelque chose à un moment donné.
Pensez à LiveData
un observable qui vous permet de gérer les observateurs qui sont dans un active
état. En d'autres termes, LiveData
c'est un simple observable mais prend également en charge le cycle de vie.
Mais voyons les deux cas de code que vous demandez:
A) Données en direct
B) RXJava
A) Ceci est une implémentation de base de LiveData
1) vous instanciez généralement LiveData dans le ViewModel pour maintenir le changement d'orientation (vous pouvez avoir LiveData en lecture seule, ou MutableLiveData en écriture, donc vous exposez généralement en dehors de la classe LiveData)
2) dans la OnCreate
méthode de l' activité principale (pas le ViewModel), vous «abonnez» un objet Observer (généralement une méthode onChanged)
3) vous lancez la méthode observer pour établir le lien
D'abord le ViewModel
(possède la logique métier)
class ViewModel : ViewModel() {
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 {
})
}
}
}
B) Ceci est l'implémentation de base de RXJava
1) vous déclarez un observable
2) vous déclarez un observateur
3) vous souscrivez à l'Observable avec l'Observer
Observable.just(1, 2, 3, 4, 5, 6)
.subscribe(new Subscriber() {
@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, il LiveData
est utilisé avec Lifecycle
et souvent avec ViewModel
(comme nous l'avons vu) des composants d'architecture. En fait, quand LiveData
est combiné avec un ViewModel vous permet de garder à jour en temps réel chaque changement dans l'Observer, de sorte que les événements sont gérés en temps réel là où c'est nécessaire. L'utilisation LiveData
est fortement recommandée pour connaître le concept de cycle de vie et les objets relatifs LifeCycleOwner / LifeCycle , aussi je vous suggère de jeter un oeil à Transformations , si vous souhaitez implémenter LiveData
dans des scénarios de la vie réelle. Vous trouverez ici quelques cas d'utilisation du grand logiciel commun .
Pour conclure essentiellementLiveData
est unesimplifiéeRXJava
,une manière élégante d'observerchangements sur plusieurs composants sans créerrègles de dépendance explicites soidisant entre les composants,sorte que vous pouvez tester beaucoup plus facile le code etrendre beaucoup plus facilelire. RXJava, vous permet de faire les choses de LiveData et bien plus encore. En raison des fonctionnalités étendues de RXJava, vous pouvez à la fois utiliser LiveData pour des cas simples ou exploiter toute la puissance de RXJava continuer à utiliser des composants d'architecture Android comme ViewModel , bien sûr, cela signifie que celaRXJava
peut être beaucoup plus complexe, pensez simplement à des centaines d'opérateurs à la place 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 méthode dite fonctionnelle pour gérer le flux du programme.