¿Cómo manejar los cambios de configuración en Android?

A veces, el dispositivo Android sufre cambios de configuración durante el tiempo de ejecución de la aplicación. Mientras el dispositivo experimenta cambios en la configuración, se recrean todas las actividades y fragmentos. Este reinicio de la aplicación mientras los cambios de configuración ayudan a la aplicación a adaptarse a las nuevas configuraciones al recargar automáticamente los recursos alternativos de la aplicación que coinciden con la nueva configuración del dispositivo. Y mientras sucede esta recreación de actividades y fragmentos, los datos y la interfaz de usuario deben restaurarse. La forma tradicional de hacer esto es usar paquetes y manejar las devoluciones de llamada de onSavedInstanceStae() . Consulte ¿Cómo restaurar datos en la configuración modificada en Android usando paquetes?. Ahora eche un vistazo a la siguiente imagen de cómo se pierden los datos durante los cambios de configuración si no se manejan correctamente. Entonces, en esta discusión, se demostró cómo podemos restaurar los datos y actualizar la interfaz de usuario después de los cambios de configuración.

Nota: Esta discusión se implementa en el lenguaje de programación Kotlin .

Pasos para manejar los cambios de configuración en android

Paso 1: Cree un proyecto de Android Studio de actividad vacía

Cree un proyecto de Android Studio 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

Este proyecto necesita la dependencia de las extensiones Lifecycle, ViewModels y Livedata . Por lo tanto, agregue las siguientes dependencias al archivo Gradle de nivel de aplicación.

// lifecycle_version y la versión de la arquitectura pueden variar
def lifecycle_version = “2.3.1”
def arch_version = “2.1.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”

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

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

// arquitectura Extensiones del ciclo de vida

implementación «androidx.lifecycle:lifecycle-extensions:$arch_version»

Paso 3: trabajar con el archivo activity_main.xml

El diseño principal de la aplicación contiene un botón y un TextView . Para implementar lo mismo, invoque el siguiente código dentro del 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"
    android:orientation="vertical"
    tools:context=".MainActivity"
    tools:ignore="HardcodedText">
  
    <TextView
        android:id="@+id/textView"
        style="@style/TextAppearance.MaterialComponents.Headline3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="0"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
  
    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="INCREMENT"
        app:layout_constraintEnd_toEndOf="@+id/textView"
        app:layout_constraintStart_toStartOf="@+id/textView"
        app:layout_constraintTop_toBottomOf="@+id/textView" />
  
</androidx.constraintlayout.widget.ConstraintLayout>

Interfaz de usuario de salida:

Paso 4: comprender el alcance de ViewModel durante toda la actividad

• Al hacer referencia a la siguiente imagen, se observa que los objetos de ViewModel están en el ámbito del propietario del ciclo de vida pasado a ViewModelProvider al obtener ViewModel. El objeto ViewModel permanece en la memoria durante todo el ciclo de vida del propietario del ciclo de vida. Aquí, el propietario del ciclo de vida es MainActivity.kt, que tiene su propio ciclo de vida.
• En caso de actividad, cuando la actividad ha terminado, se destruye el alcance del objeto ViewModel. En el caso del Fragmento , cuando se separa.
• El objeto ViewModel creado cuando el sistema llama al método onCreate() . Puede ser llamado varias veces, a lo largo de la vida de la actividad. Como cuando se gira el dispositivo. El objeto ViewModel aún existe cuando se solicitó por primera vez hasta que la actividad finaliza y se destruye.

Paso 5: Creación de ViewModel para la actividad

La clase ViewModel hereda ViewModel como la superclase. Y los miembros de datos requeridos y las funciones de miembros se crean dentro de él, en el que el alcance de todos los miembros de datos y las funciones permanecen durante toda la vida de la actividad. Para implementar ViewModel, cree una clase llamada MyViewModel.kt e invoque el siguiente código.

import androidx.lifecycle.ViewModel
  
class MyViewModel : ViewModel() {
  
    // number to increment and show on UI
    var number = 0
  
    // function when called increments the value of number
    fun addNumber(): Int = number++
  
}

Paso 6: Trabajar con MainActivity.kt

En el archivo MainActivity.kt , el objeto de ViewModel se crea utilizando ViewModelProvider, del propietario del ciclo de vida. Aquí, el propietario del ciclo de vida es el archivo MainAactivity.kt. Para implementar lo mismo, invoque el siguiente código dentro del archivo MainActivity.kt .

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import androidx.lifecycle.ViewModelProvider
  
class MainActivity : AppCompatActivity() {
  
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
  
        // create instance of the viewModel of the Custom MyViewModel for the activity MainActivity.kt
        val myViewModel: MyViewModel = ViewModelProvider(this).get(MyViewModel::class.java)
  
        // create instances of the UI elements
        val button: Button = findViewById(R.id.button)
        val textView: TextView = findViewById(R.id.textView)
  
        textView.text = myViewModel.number.toString()
        button.setOnClickListener {
            // trigger the increment
            // function to increment the value
            myViewModel.incrementNumber()
  
            // set the updated value of number to the TextView
            textView.text = myViewModel.number.toString()
        }
    }
}

Producción: