LiveData vs ObservableField en Android

LiveData ayuda a reducir las fugas de memoria y el manejo manual del ciclo de vida. También garantiza que la interfaz de usuario esté siempre actualizada con los datos, incluso cuando la actividad de la aplicación se reinicia mientras todavía estamos usando nuestra aplicación. Es una parte de los patrones de arquitectura de Android. Se utiliza para observar cambios en la vista y actualizar la vista cuando está ACTIVA. Por lo tanto, LiveData es consciente del ciclo de vida.

Una clase observable que contiene un objeto parcelable ( permite que los objetos lean y escriban desde Paquetes que pueden contener datos aplanados dentro de contenedores de mensajes ). Un contenedor de objetos para hacerlo observable. Las clases ObservableField se pueden usar en lugar de crear un objeto Observable. Si su clase de objeto tiene menos propiedades para actualizar o si no desea observar todos los campos del objeto, puede usar ObservableFields para actualizar la interfaz de usuario. Puede declarar la variable como ObservableField y, cuando se establezcan los nuevos datos, la interfaz de usuario se actualizará.

A diferencia de los objetos que implementan Observable, como los campos observables, los objetos LiveData conocen el ciclo de vida de los observadores suscritos a los cambios de datos. Este conocimiento permite muchos beneficios, que se explican en Las ventajas de usar LiveData. En Android Studio versión 3.1 y superior, puede reemplazar campos observables con objetos LiveData en su código de enlace de datos. Hay situaciones en las que quizás prefiera usar un componente de modelo de vista que implemente la interfaz Observable en lugar de usar objetos LiveData, incluso si pierde las capacidades de administración del ciclo de vida de LiveData. El uso de un componente View Model que implementa Observable le brinda más control sobre los adaptadores de enlace en su aplicación. Por ejemplo, este patrón le brinda más control sobre las notificaciones cuando cambian los datos,

similitudes

• Ambos funcionan bien con el enlace de datos, lo que le permite vincular los componentes de la interfaz de usuario en sus diseños XML a las fuentes de datos de su aplicación.
• Las vistas enlazadas cancelan automáticamente la suscripción cuando están en segundo plano.
• Las clases Plain Old Java Object también pueden usar estos cambios.

diferencias

• LiveData permite a los suscriptores de Plain Old Java Object conocer el ciclo de vida, lo que significa que si tiene una propiedad B que desea actualizar cuando cambia A, puede optar por no recibir actualizaciones cuando la vista adjunta está inactiva. Esto ahorra espacio/recursos en su aplicación.
• Las actualizaciones de subprocesos en segundo plano de ObservableField son rápidas.  MutableLiveData.postData relativamente lento.
• Los valores de LiveData<T> y ObservableField<T> siempre son nulos, pero las implementaciones primitivas (algo que no se refiere directamente al algoritmo o al comportamiento) Observable -Integer, -Floating, -Boolean, etc. no son nulas.
• MutableLiveData<T> no toma un valor de constructor para establecer en la inicialización.

¿Cuándo usar qué?

• ¿Tiene eventos externos que pueden desenstringr cambios en la API de procesamiento de datos, la API de integración, el planificador de procesos y el programador de procesos en el modelo de vista cuando la aplicación está en segundo plano? Probablemente deberías optar por LiveData
• ¿Necesita que la actualización de valores en subprocesos en segundo plano sea rápida e inmediata? Usar observables
• ¿Ninguno de los requisitos anteriores? Puede usar ambos, pero ObservableField es fácil de usar y puede cambiar las implementaciones según su elección que no puede hacer en datos en vivo.

Ahora, comprendamos ObservableField y por qué se requería LiveData incluso cuando ObservableField estaba presente .

• ObservableField no es consciente del ciclo de vida, pero LiveData es consciente del ciclo de vida y, por lo tanto, notificará solo los observables que están «activos».
• Tenemos que hacer el manejo manual de la conciencia del ciclo de vida en ObservableField.

ViewModel + LiveData + Enlace de datos = IU reactiva

// LiveData
  
class SampleViewModel : ViewModel() {
  
    // Create a LiveData with a String
    val currentName : MutableLiveData<String> by lazy
    {
        MutableLiveData<String>()
    }
  
    // Rest of the ViewModel...
}
  
// Declaring it
val liveDataA = MutableLiveData<String>()
                // Trigger the value change
                liveDataA.value
    = someValue
    // Optionally, one could use liveDataA.postValue(value)
    // to get it set on the UI thread

¿Cuáles son los beneficios de usar LiveData?

• Sin fugas de memoria : como los observadores están vinculados al ciclo de vida de la aplicación, cuando no es necesario, se destruye.
• Sin bloqueos debido a la actividad detenida : como la actividad no está en uso, también lo está LiveData. Entonces, la transmisión de datos se detiene, lo que detiene los bloqueos en la pila posterior.
• Cambios de configuración : maneja los datos más recientes cuando se recrea la vista debido a la rotación de la pantalla.

Puede usar LiveData todo el tiempo, siempre que haya un Propietario del ciclo de vida para observar. Prefiero mantener los campos vinculados que solo son relevantes para ViewModel como Observable y usar LiveData para los campos cuyos cambios de estado también son relevantes para la actividad o el fragmento.

// ObservableField
  
public class MyDataObject {
    private Context context;
    public final ObservableField<String> A
        = new ObservableField<String>();
    public final ObservableField<String> B
        = new ObservableField<String>();
    public final ObservableField<String> display
        = new ObservableField<String>(A, B) {
              @Override public String get()
              {
                  return context.getResources().getString(
                      R.string.name, first.get, last.get());
              }
          };
    public final ObservableInt age = new ObservableInt();
}