example - ¿Cuándo usar RxJava en Android y cuándo usar LiveData de Android Architectural Components?

rxjava example (7)

No obtengo la razón para usar RxJava en Android y LiveData de Android Architectural Components. Sería realmente útil si los casos de uso y las diferencias entre ambos se explican junto con un ejemplo de ejemplo en forma de código que explica las diferencias entre ambos.

Android LiveData es una variante del patrón de observación original, con la adición de transiciones activas / inactivas. Como tal, es muy restrictivo en su alcance.

Usando el ejemplo descrito en Android LiveData , se crea una clase para monitorear los datos de ubicación y registrar y cancelar el registro en función del estado de la aplicación.

RxJava proporciona operadores que están mucho más generalizados. Supongamos que este observable proporcionará datos de ubicación:

Observable<LocationData> locationObservable;

La implementación del observable se puede construir utilizando Observable.create() para asignar las operaciones de devolución de llamada. Cuando el observable se suscribe, la devolución de llamada se registra, y cuando se cancela la suscripción, la devolución de llamada no se registra. La implementación se ve muy similar al código proporcionado en el ejemplo.

Supongamos también que tiene un observable que emite true cuando la aplicación está activa:

Observable<Boolean> isActive;

Entonces puede proporcionar toda la funcionalidad de LiveData de la siguiente manera

Observable<LocationData> liveLocation = isActive .switchMap( active -> active ? locationObservable : Observable.never() );

El operador switchMap() proporcionará la ubicación actual como una secuencia o nada si la aplicación no está activa. Una vez que tenga el liveLocation observable, hay muchas cosas que puede hacer con los operadores de RxJava. Mi ejemplo favorito es:

liveLocation.distinctUntilChanged() .filter( location -> isLocationInAreaOfInterest( location ) ) .subscribe( location -> doSomethingWithNewLocation( location ) );

Eso solo realizará la acción cuando la ubicación haya cambiado, y la ubicación sea interesante. Puede crear operaciones similares que combinen operadores de tiempo para determinar la velocidad. Más importante aún, puede proporcionar un control detallado de si las operaciones suceden en el hilo principal, o en un hilo de fondo, o en varios hilos, utilizando operadores RxJava.

El punto de RxJava es que combina el control y el tiempo en un solo universo, utilizando operaciones proporcionadas por la biblioteca, o incluso operaciones personalizadas que usted proporciona.

LiveData se dirige solo a una pequeña parte de ese universo, el equivalente a construir liveLocation .

Como puede saber en el ecosistema reactivo, tenemos un Observable que emite datos y un Observador que se suscribe (recibe una 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 una notificación de que Observable grita algo 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 Observable simple 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) generalmente crea una instancia de LiveData en ViewModel para mantener el cambio de orientación (puede tener LiveData que es de solo lectura o MutableLiveData que se puede escribir, por lo que generalmente se expone fuera de la clase LiveData)

2) en el método OnCreate de la Actividad principal (no en el ViewModel) "suscribe" un objeto Observador (generalmente un método onChanged)

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

Primero ViewModel (posee la lógica de negocios)

class ViewModel : ViewModel() { //Point 1 var liveData: MutableLiveData<Int> = MutableLiveData() }

Y esta es la MainActivity (lo más tonto 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) declaras un Observable

2) declaras un observador

3) suscribes 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 componentes de arquitectura ViewModel (como hemos visto). De hecho, cuando LiveData se combina con un ViewModel le permite mantenerse actualizado en tiempo real de cada cambio en el Observador, para que los eventos se gestionen en tiempo real donde sea necesario. Para usar LiveData se recomienda encarecidamente conocer el concepto de lifecycle de lifecycle y los objetos relativos LifeCycleOwner/LifeCycle , también le sugiero que eche un vistazo a Transformations , si desea implementar LiveData en escenarios de la vida real. Aquí puede encontrar algunos casos de uso del gran commonsware .

Para LiveData 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 el código mucho más fácilmente y hacerlo mucho más legible. RXJava, te permite hacer cosas de LiveData y mucho más. Debido a las funcionalidades extendidas de RXJava, puede usar LiveData para casos simples o explotar todo el poder de RXJava para seguir usando los componentes de Android Architecture como 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 (por el 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.

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 los ciclos de vida de Android y ViewModel . RxJava proporciona más capacidades en transformaciones (como lo menciona @Bob Dalgleish).

Actualmente, estamos usando RxJava en la fuente de datos y las capas de repositorio, 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 , entonces, ¿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 en observables en un objeto CompositeDispoable y luego disponerlas en onDestroy() de la Activity o onDestroyView() del Fragment usando solo una línea de código?

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

Pero en resumen, sí, podría, pero eso necesitaría primero anular los métodos relevantes del ciclo de vida además de tener el conocimiento básico del ciclo de vida. Es posible que esto todavía no tenga sentido para algunos, pero el hecho es que, según una de las sesiones de Jetpack en Google I / O 2018, muchos desarrolladores encuentran complejo el manejo 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 conocen el ciclo de vida, se olvidan de ocuparse de eso en cada Actividad / Fragmento que usan en su aplicación. En aplicaciones grandes, esto podría convertirse en un problema, a pesar del efecto negativo que podría tener sobre la productividad.

La conclusión es que al presentar LiveData , se espera que un mayor número de desarrolladores adopten MVVM sin siquiera tener que comprender la gestión del ciclo de vida, la pérdida de memoria y el bloqueo. Aunque no tengo dudas de que LiveData no es comparable con RxJava en términos de capacidades y el poder que brinda a los desarrolladores, la programación reactiva y RxJava es un concepto y una herramienta difíciles 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 problema polémico generalizado experimentado por muchos desarrolladores.

** ACTUALIZACIÓN ** He agregado un nuevo artículo here donde he explicado cómo el mal uso de LiveData puede conducir a resultados inesperados. RxJava puede venir a rescatar en estas situaciones

Hay muchas diferencias entre LiveData y RxJava:

LiveData no es un STREAM mientras que en RxJava todo (literalmente todo) es un STREAM .
LiveData es una clase de titular de datos observable. A diferencia de un observable regular, LiveData es consciente del ciclo de vida, lo que significa que respeta el ciclo de vida de otros componentes de la aplicación, como actividades, fragmentos o servicios. Esta conciencia garantiza que LiveData solo actualiza los observadores de componentes de la aplicación que se encuentran en un estado de ciclo de vida activo.
LiveData es sincrónico , por lo que no puede ejecutar un fragmento de código (llamada de red, manipulación de la base de datos, etc.) de forma asincrónica utilizando solo LiveData como lo hace con RxJava.
Lo mejor que puede hacer para aprovechar al máximo este dúo es usar RxJava para su lógica de negocios (llamada de red, manipulación de datos, etc., cualquier cosa que ocurra dentro y más allá del repositorio ) y usar LiveData para su capa de presentación. Con esto, obtiene capacidades de transformación y transmisión para su lógica de negocio y operación consciente del ciclo de vida para su IU.
LiveData y RxJava se complementan si se usan juntos. Lo que quiero decir es que haga todo con RxJava y, al final, cuando desee actualizar la interfaz de usuario, haga algo como el código que figura a continuación para cambiar su Observable a LiveData. Entonces, su Vista (UI) observa los LiveData en ViewModel donde su LiveData no es más que MutableLiveData no mutable (o MutableLiveData es LiveData mutable).
Entonces la pregunta aquí es, ¿por qué deberías usar LiveData en primer lugar? Como puede ver a continuación en el código, almacena su respuesta de RxJava a MutableLiveData (o LiveData) y su LiveData es consciente del ciclo de vida, por lo que, en cierto modo, sus datos lo son. Ahora, imagine la posibilidad de que sus datos sepan cuándo y cuándo no actualizar la IU.
LiveData no tiene un historial (solo el estado actual). Por lo tanto, no debe usar LiveData para una aplicación de chat.
Cuando usa LiveData con RxJava, no necesita cosas como MediatorLiveData , SwitchMap , etc. Son herramientas de control de flujo y RxJava es mejor en muchas ocasiones.
Vea LiveData como un titular de datos y nada más. También podemos decir que LiveData es un consumidor consciente del ciclo de vida.

public class RegistrationViewModel extends ViewModel { private RegistrationRepo registrationRepo; private MutableLiveData<RegistrationResponse> modelMutableLiveData = new MutableLiveData<>(); public RegistrationViewModel() { } public RegistrationViewModel(RegistrationRepo registrationRepo) { this.registrationRepo = registrationRepo; } public void init(RegistrationModel registrationModel) { disposable = registrationRepo.loginForUser(registrationModel) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Consumer<Response<RegistrationResponse>>() { @Override public void accept(Response<RegistrationResponse> registrationModelResponse) throws Exception { modelMutableLiveData.setValue(registrationModelResponse.body()); } }); } public LiveData<RegistrationResponse> getModelLiveData() { return modelMutableLiveData; } }

LiveData es un subconjunto de los componentes de la arquitectura de Android desarrollado por el equipo de Android.

Con los datos en vivo y otros componentes de la arquitectura, los componentes de la arquitectura manejan las pérdidas de memoria y otros problemas similares. Dado que está desarrollado por el equipo de Android, es el mejor para Android. También proporcionan actualizaciones que manejan nuevas versiones de Android.

Si solo desea usar en el desarrollo de aplicaciones de Android, vaya a los componentes de arquitectura de Android. De lo contrario, si desea utilizar otra aplicación Java, como aplicaciones web, aplicaciones de escritorio, etc., use RxJava

LiveData como titular de datos y nada más. También podemos decir que LiveData es un consumidor consciente del ciclo de vida. Se recomienda encarecidamente a LiveData que conozca el concepto de ciclo de vida y los objetos relativos LifeCycleOwner / LifeCycle, obtendrá capacidades de transformación y transmisión para su lógica empresarial y operación consciente del ciclo de vida para su IU.

Rx es una herramienta poderosa que permite resolver problemas en un elegante estilo declarativo. Maneja las opciones del lado comercial o las operaciones de Service Api