¿Cuándo usar RxJava en Android y cuándo usar LiveData desde componentes arquitectónicos de Android?

Con respecto a la pregunta original, tanto RxJava como LiveData se complementan muy bien.

LiveData brilla en la capa ViewModel, con su estrecha integración con Android lifecycles y ViewModel. RxJava proporciona más capacidades en transformaciones (como mencionó @Bob Dalgleish).

Actualmente, estamos usando RxJava en las capas de origen y repositorio de datos, y se transforma en LiveData (usando LiveDataReactiveStreams) en ViewModels (antes de exponer datos a actividades / fragmentos) - bastante contento con este enfoque.

De hecho, LiveData no es una herramienta esencialmente diferente a RxJava, así que ¿por qué se introdujo como un componente de arquitectura cuando RxJava podría haber gestionado fácilmente el ciclo de vida almacenando todas las suscripciones a observables en un objeto CompositeDispoable y luego disponiéndolas en onDestroy() del Activity o onDestroyView() del Fragment usando solo una línea de código?

He respondido a esta pregunta completamente construyendo una aplicación de búsqueda de películas una vez usando RxJava y luego usando LiveData aquí.

Pero en resumen, sí, podría, pero eso necesitaría primero anular los métodos de ciclo de vida relevantes además de tener el conocimiento básico del ciclo de vida. Esto todavía podría no tener sentido para algunos, pero el hecho es que de acuerdo con una de las sesiones de Jetpack en Google I/O 2018 muchos desarrolladores encuentran compleja la gestión del ciclo de vida. Los errores de bloqueo que surgen de no manejar la dependencia del ciclo de vida podrían ser otra señal de que algunos desarrolladores, incluso si ciclo de vida, olvidarse de cuidar de que en cada Actividad / Fragmento que utilizan en su aplicación. En aplicaciones grandes, esto podría convertirse en un problema, a pesar del efecto negativo que podría tener en la productividad.

La conclusión es que al introducir LiveData, se espera que un mayor número de desarrolladores adopten MVVM sin siquiera tener que entender la gestión del ciclo de vida, la fuga de memoria y el bloqueo. Aunque no tengo ninguna duda de que LiveData no es comparable con RxJava en términos de capacidades y el poder que da a los desarrolladores, la programación reactiva y RxJava es un concepto y una herramienta difícil de entender para muchos. Por otro lado, no creo que LiveData esté destinado a ser un reemplazo de RxJava, simplemente no puede, sino una herramienta muy simple para manejar un controvertido problema generalizado experimentado por muchos desarrolladores.

Como usted puede saber en el ecosistema reactivo tenemos un Observable que emite datos y un Observador que suscribe( recibe notificación) de esta emisión Observable, nada extraño es cómo funciona el llamado Patrón de Observador. Un Observable "grita" algo, el Observador recibe notificación de que algo Observable grita en un momento dado.

Piense en LiveData como un Observable que le permite administrar los Observadores que están en un estado active. En otros términos LiveData es un simple Observable pero también se encarga del ciclo de vida.

Pero veamos los dos casos de código que solicita:

A) Datos en vivo

B) RxJava

A) Esta es una implementación básica de LiveData

1) por lo general instanciar LiveData en el ViewModel para mantener el cambio de orientación (puede tener LiveData que es de solo lectura, o MutableLiveData que es escribible, por lo que generalmente se expone fuera de la clase LiveData)

2) en el método OnCreate de la actividad Main (no el ViewModel) usted "suscribe" un objeto Observer (generalmente un método a onChanged)

3) se inicia el método observar para establecer el enlace

Primero el ViewModel (posee la lógica de negocio)

class ViewModel : ViewModel() { //Point 1

var liveData: MutableLiveData<Int> = MutableLiveData()

}

Y este es el MainActivity( tan tonto como sea posible) 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) Esta es la implementación básica de RxJava

1) usted declara un Observable

2) usted declara un Observador

3) se suscribe el Observable con el Observador

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 particular LiveData se usa con Lifecycle y a menudo con ViewModel (como hemos visto) componentes de arquitectura. De hecho, cuando LiveData se combina con un ViewModel le permite mantener actualizado en tiempo real cada cambio en el Observador, para que los eventos se gestionen en tiempo real donde sea necesario. Para utilizar LiveData es muy recomendable conocer el concepto de lifecycley los objetos relativos LifecycleOwner/LifeCycle, también le sugeriría que eche un vistazo a Transformaciones, si desea implementar LiveData en escenarios de la vida real. Aquí puede encontrar algunos casos de uso de la gran commonswear.

Para terminar básicamente LiveData es un RXJava simplificado, una forma elegante de observar los cambios en múltiples componentes sin crear reglas de dependencia explícitas entre los componentes, para que pueda probar mucho más fácil el código y hacerlo mucho más legible. RxJava, le permite hacer las cosas de LiveData y mucho más. Debido a las funcionalidades extendidas de RxJava, ambos pueden usar LiveData para casos simples o explotar toda la potencia de RxJava seguir usando componentes de arquitectura Android como el ViewModel , por supuesto esto significa que RXJava puede ser mucho más complejo, solo piense que tiene cientos de operadores en lugar de switchMap y Map of LiveData (en momento).

RxJava versión 2 es una biblioteca que revolucionó el paradigma orientado a Objetos, agregando una llamada forma funcional de administrar el flujo del programa.

LiveData es un subconjunto de los componentes de la arquitectura de Android desarrollado por android team.Con los datos en vivo y otros componentes de arquitectura (Es el mejor ajuste para Android.Las fugas de memoria, etc. son manejadas por componentes de arquitectura.Ya que está desarrollado por Android team.So se adapta mejor a Android, proporcionan actualizaciones con respecto a las nuevas versiones de Android, etc.) podemos hacer lo que podemos lograr en RxJava.
Si desea utilizar en Android solo significa ir a la arquitectura de Android componentes y si desea utilizar el módulo ur en Android y otros medios (aplicación Java,etc.) vaya a RxJava (react native)