LifecycleObserever con actividades en Android

LifecycleObserever is Observer es uno de los componentes de la arquitectura Jetpack y es una interfaz que observa y realiza la tarea especificada según los cambios del ciclo de vida del propietario del ciclo de vida. Por ejemplo, MainActivity tiene su propio ciclo de vida y es propietario del ciclo de vida y podemos implementar la interfaz LifecycleObserever y adjuntar este observador a MainActivity para que se puedan realizar ciertas operaciones a medida que cambia el ciclo de vida de MainActivity. En este artículo, se demostró cómo LifecycleObserever realiza las tareas a medida que cambia el ciclo de vida del propietario del ciclo de vida. Mire el siguiente video para obtener una descripción general de la discusión.

Nota: esta discusión se implementa utilizando el lenguaje Kotlin.

Pasos para implementar LifecycleObserever para la aplicación de Android

Paso 1: crear un proyecto de actividad vacío

Cree un proyecto de estudio de Android de actividad vacío y seleccione Kotlin como lenguaje de programación. Consulte Android | ¿Cómo crear/comenzar un nuevo proyecto en Android Studio?

Paso 2: Agregar las dependencias requeridas

Agregue las siguientes dependencias al archivo Gradle de nivel de aplicación. Las dependencias son del ciclo de vida.

// Solo ciclos de vida (sin ViewModel o LiveData)

implementación «androidx.lifecycle:lifecycle-runtime-ktx:2.3.1»

// Procesador de anotaciones

kapt «androidx.lifecycle:lifecycle-compilador:2.3.1»

Nota: La versión puede diferir en el futuro.

Y también habilite el complemento kapt dentro de los complementos en el archivo gradle de nivel de aplicación.

complementos {

   id ‘com.android.aplicación’

   id ‘kotlin-android’

   id ‘kotlin-kapt’

}

Si no puede saber cómo agregar dependencias, mire las siguientes imágenes.

Paso 3: trabajar con el archivo acitivity_main.xml

El diseño principal de la aplicación es el archivo activity_main.xml que contiene solo un TextView. Para implementar la interfaz de usuario, invoque el siguiente código dentro del archivo activity_main.xml .

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    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"
    android:orientation="vertical"
    tools:context=".MainActivity">
  
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_marginTop="128dp"
        android:text="GEEKSFORGEEKS"
        android:textSize="24sp" />
  
</LinearLayout>

Interfaz de usuario de salida:

Paso 4: Cree una clase que implemente LifecycleObserver

Cree una clase MainActivityObserver.kt que implemente la interfaz LifecycleObserver que contiene las funciones para realizar las tareas asignadas, a medida que cambia el ciclo de vida del propietario. En este caso, el propietario es MainActivity.kt , que tiene su propio ciclo de vida. a través de la siguiente clase se observan los cambios en el ciclo de vida de MainActivity . Invoque el siguiente código dentro del archivo MainActivityObserver.kt .

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
  
class MainActivityObserver : LifecycleObserver {
  
    private val TAG = javaClass.simpleName
  
    // To observe the onCreate state of MainActivity
    // and perform the assigned tasks
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreatePerformTask() {
        // here for demonstration purpose the Log messages are printed in logcat
        // one may perform their own custom tasks
        Log.i(TAG, "I\'m inside Observer of MainActivity ON_CREATE")
    }
  
    // To observe the onResume state of MainActivity
    // and perform the assigned tasks
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResumePerformTask() {
        // here for demonstration purpose the Log messages are printed in logcat
        // one may perform their own custom tasks
        Log.i(TAG, "I\'m inside Observer of MainActivity ON_RESUME")
    }
}

Paso 5: Adjuntar MainActivityObserver al archivo MainActivity.kt

Ahora es necesario informar la actividad adjuntando el observador MainActivityObserver para que las tareas deseadas se puedan realizar a medida que cambia el estado de la actividad. Invoque el siguiente código dentro del archivo MainActivity.kt .

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
  
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
  
        // attach the MainActivityObserver 
          // to the MainActivity as follows
        lifecycle.addObserver(MainActivityObserver())
    }
}

Producción: 

Aquí, la salida se muestra en el logcat , ya que hay una declaración de registro de información dentro de la clase de observador.