LiveData en los componentes de la arquitectura de Android

LiveData es uno de los componentes de la arquitectura de Android . LiveData es una clase de titular de datos observables . ¿Cuál es el significado de observable aquí? Observable significa que los datos en vivo pueden ser observados por otros componentes como actividad y fragmentos .(Controlador de interfaz de usuario). Lo más importante de LiveData es que tiene el conocimiento sobre el ciclo de vida de sus observadores como actividad o fragmento. Eso significa que los datos en vivo solo actualizan los componentes de la aplicación, como Actividad o Fragmentos, que están en estado de ciclo de vida activo. LiveData notifica al observador (Actividad o Fragmento) que están en estado de ciclo de vida Iniciado o Reanudado. Los observadores inactivos registrados para ver objetos LiveData no reciben notificaciones sobre los cambios. Aquí se entiende por observadores inactivos los que no están en estado de Iniciado o Reanudado. Se puede registrar un observador emparejado con un objeto que implementa la interfaz LifecycleOwner que veremos en nuestro ejemplo. Esta relación permite eliminar al observador cuando el estado del objeto del ciclo de vida correspondiente cambia a DESTRUIDO.

Este componente es una clase de titular de datos observable, es decir, el valor contenido se puede observar. LiveData es un componente consciente del ciclo de vida y, por lo tanto, realiza sus funciones de acuerdo con el estado del ciclo de vida de otros componentes de la aplicación. Además, si el estado del ciclo de vida del observador está activo, es decir, INICIADO o REANUDADO, solo entonces LiveData actualiza el componente de la aplicación. LiveData siempre verifica el estado del observador antes de realizar cualquier actualización para asegurarse de que el observador debe estar activo para recibirlo. Si se destruye el estado del ciclo de vida del observador, LiveData es capaz de eliminarlo y, por lo tanto, evita pérdidas de memoria. Facilita la tarea de sincronización de datos.

Es necesario implementar métodos onActive y onInactive por LiveData:

clase LocationLiveData (contexto: Contexto)

   : LiveData<Ubicación>(), AnkoLogger, LocationListener {

   valor privado locationManager: LocationManager =

           context.getSystemService(Context.LOCATION_SERVICE) como LocationManager

   anular la diversión onActive() {

       información («onActive»)

       locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0f, este)

   }

   anular la diversión onInactive() {

       info(“onInactive”)

       locationManager.removeUpdates(esto)

   }

   // ….

}

Para observar un método de observador del componente LiveData (LifecycleOwner, Observer<T>) se llama:

diversión observarUbicación() {

       val ubicación = LocationLiveData (este)

       ubicación.observar(esto,

               Observador { ubicación ->

                   info(“ubicación: $ubicación”)

               })

   }

}

Implementación en la aplicación de Android

En este ejemplo, solo crearemos una aplicación de contador simple, que solo cuente 5 segundos, puede hacer cualquier cosa con LiveData, pero por ahora construyamos esta pequeña aplicación. 

Paso 1: agregue estas dependencias en su archivo build.gradle

def ciclo_de_vida_versión = “2.3.0”

// Ver modelo

implementación «androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version»

// Datos en tiempo real

implementación “androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version”

implementación “androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version”

implementación “androidx.core:core-ktx:1.3.2”

Paso 2: trabajar con el archivo activity_main.xml

Vaya a la aplicación > res > diseño > actividad_principal.xml y agregue el siguiente código a ese archivo. A continuación se muestra el código para el archivo activity_main.xml .

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
 
    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="0"
        android:textSize="25sp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
 
</androidx.constraintlayout.widget.ConstraintLayout>

 
Paso 3: Cree un archivo de clase Kotlin MainActivityViewModel.kt. Nuestro archivo de clase MainActivity amplía la clase ViewModel . 

Consulte este artículo: ¿Cómo crear clases en Android Studio?

import androidx.lifecycle.ViewModel
 
class MainActivityViewModel:ViewModel() {
 
    private val _seconds = MutableLiveData<Int>()
    private val _finished = MutableLiveData<Boolean>()
 
    // getter method for seconds var
    fun seconds():LiveData<Int>{
        return _seconds
    }
     
    // getter method for finished var
    fun finished():LiveData<Boolean>{
        return _finished
    }
 
 
    // Counter method that uses CountDownTimer()
    fun startCounter(){
     
        // you can change the millisInFuture value
        object : CountDownTimer(5000, 100) {
            override fun onTick(millisUntilFinished: Long) {
                val time = millisUntilFinished / 1000
                 
                // setting the count value
                _seconds.value = time.toInt()
            }
 
            override fun onFinish() {
                 // if millisInFuture completed
                 // it set the value true
                _finished.value = true
            }
        }.start()
    }
}

Nota : aquí estamos usando MutableLiveData a la derecha. ¿Pero la pregunta es porqué? debido a que LiveData ya está disponible, MutableLiveData extiende la clase LiveData y dos funciones setValue() y postValue() están disponibles públicamente para su uso.

Paso 4: trabajar con el archivo MainActivity.kt

Vaya al archivo MainActivity.kt  y consulte el siguiente código. A continuación se muestra el código del archivo MainActivity.kt  .  

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
         
        // creating instance of our ViewModel class
        val viewModel = ViewModelProvider(this).get(MainActivityViewModel::class.java)
 
        // calling start counter methods which is in our viewmodel class
        viewModel.startCounter()
 
         
        // observing the second value of our view model class
        viewModel.seconds().observe(this, Observer {
            
            // setting textview value
            textView.text = it.toString()
        })
 
        viewModel.finished().observe(this, Observer {
            if(it){
                // if count time finished it set the value
                textView.text = "Finished"
            }
        })
    }
}

Nota: Aquí, dentro de Observe(), «este» es el propietario del ciclo de vida, como discutimos anteriormente para observar el valor, debemos pasar el propietario del ciclo de vida. Aquí esto significa MainActivity que es el observador aquí.

Producción: 

Ventajas de usar LiveData

• No es necesario actualizar la interfaz de usuario cada vez: LiveData sigue el patrón del observador. LiveData notifica a los objetos Observer cuando se produce algún cambio.
• Sin fugas de memoria: los observadores están vinculados a los objetos del ciclo de vida y se limpian cuando se destruye su ciclo de vida asociado.
• No más manejo manual del ciclo de vida: los componentes de la interfaz de usuario solo observan los datos relevantes y no detienen ni reanudan la observación. LiveData gestiona todo esto automáticamente, ya que está al tanto de los cambios de estado del ciclo de vida relevantes mientras observa.
• Cambios de configuración adecuados: si se vuelve a crear una actividad o un fragmento debido a un cambio de configuración, como la rotación del dispositivo, recibe inmediatamente los últimos datos disponibles.