Patrón Observer en Android: Implementación y Uso Práctico

Contenido del curso

Arquitectura

Patrones de diseño

10
Patrones de Diseño en Android: Creacionales, Estructurales y Comportamiento
02:34 min

Patrones de diseño creacionales

Patrones de diseño estructurales

Patrones de comportamiento

Bonus: Architecture Components

Bonus: Custom View

31
Creación de Vistas Personalizadas en Android con Custom View
08:42 min

Conclusiones

32
Patrones de Diseño y Componentes de Texto en Android
01:19 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:28

Patrón Observer en Android: Implementación y Uso Práctico

Curso de Patrones de Diseño en Android

Clase 21 de 32

Clase 21 / 32

Recursos

¿Cómo implementar el patrón de diseño Observer para manejar eventos de saldo disponible en Kotlin?

El patrón de diseño Observer es uno de los patrones de comportamiento más utilizados en el desarrollo de software por su capacidad para manejar la comunicación entre objetos de manera eficiente. En el contexto de una aplicación Android, su uso se destaca en el manejo de cambios de estado y la actualización automática de la interfaz de usuario. A continuación, revisaremos cómo puedes implementar este patrón para gestionar el saldo disponible.

¿Qué pasos seguir para crear el observador del saldo en Kotlin?

Creación de la clase del observador:

Comienza creando una nueva clase que manejará los eventos del saldo disponible. Esta clase será la observada y tendrá que implementar la interfaz Observer. Al implementar esta interfaz, se nos obligará a definir varios métodos esenciales como addObserver, removeObserver, y notifyChange.
```
class BalanceObserver : Observable() {
    // Implementación de métodos es requerida
}
```
Definición de los métodos de la interfaz:
- addObserver: Debes crear un método que registre un observador a nuestra lista de observadores, la cual puedes almacenar en una variable inmutable val observerList = mutableListOf<Observer>().
```
override fun addObserver(observer: Observer) {
    observerList.add(observer)
}
```
- removeObserver: Al igual que addObserver, necesitaremos un método que remueva un observador.
```
override fun removeObserver(observer: Observer) {
    observerList.remove(observer)
}
```
- notifyChange: Por último, cuando se produzca un cambio, el método notifyChange informará a todos los observadores sobre el nuevo valor, que se distribuirá a través de este método por medio de un bucle for.
```
override fun notifyChange(newValue: Double) {
    for (observer in observerList) {
        observer.update(newValue)
    }
}
```
Creación de una función para cambiar el saldo disponible:

Necesitamos una función pública que permita cambiar el saldo y notificar a todos los observadores sobre este cambio.
```
fun changeBalance(newAmount: Double) {
    currentBalance = newAmount
    notifyChange(newAmount)
}
```

¿Cómo integrarlo en una vista de Android?

Instanciar dentro del Fragmento o Actividad:

En el ciclo de vida adecuado del fragmento o actividad, como onViewCreated, se debe crear una instancia del observador.

private lateinit var balanceObserver: BalanceObserver

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    balanceObserver = BalanceObserver()
    balanceObserver.addObserver(YourObserverImplementation())
}

Actualizar la interfaz de usuario:

En el método update que debemos implementar al crear el observador, podemos actualizar directamente la vista cada vez que se notifique un cambio en el saldo.
```
override fun update(newBalance: Double) {
    amountTextView.text = "Saldo: $newBalance"
}
```

¿Cuáles son las mejores prácticas al usar el patrón Observer en Android?

Suscripción y desuscripción adecuada: Es crucial suscribirse y desuscribirse de los eventos en los momentos adecuados del ciclo de vida de la actividad o fragmento. La desuscripción debe realizarse cuando la actividad/fragmento se destruye para evitar fugas de memoria o excepciones de referencia nula.
Uso de genéricos: Considera implementar los observadores como genéricos para reutilizarlos en diferentes contextos y con distintos tipos de datos.
Eficiencia en la notificación de cambios: Asegúrate de que la notificación de cambios sea eficiente y se realice solo cuando sea necesario, para no afectar el rendimiento de la aplicación.

Al implementar correctamente el patrón Observer, facilitas la gestión del flujo de datos y mejoras la reactibilidad de tu aplicación, ofreciendo a los usuarios una experiencia más fluida y eficiente.

André Michel Pozos

Hace 6 años

Me propuse como reto hacer lo que dice el profesor: que las interfaces sean genéricas para que nosotros podamos usarla con cualquier tipo de dato. Simplemente fue cuestión de modificarlas de esta manera:

interface Observable2<T> {
    fun addObserver(observer: Observer2<T>)
    fun removeObserver(observer: Observer2<T>)
    fun notifyObservers(newValue: T?)
}

interface Observer2<T> {
    fun notifyChange(newValue: T?)
}

También me propuse añadir la funcionalidad de eliminar todos los observers automáticamente cuando el Fragment se destruye, tal y como lo hace LiveData. La clase quedó de esta manera:

class AvailableBalanceObservable<T>(lifecycleOwner: LifecycleOwner) : Observable2<T>
    init {
        lifecycleOwner.lifecycle.addObserver(object : LifecycleObserver {
            @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
            fun removeAllObservers() {
                amountObserverList.clear()
                lifecycleOwner.lifecycle.removeObserver(this)
            }
        })
    }
    // Resto del código
}

Un LifecycleOwner es una interfaz que implementan todas las clases que tienen un ciclo de vida, en este caso un Fragment, pero también puede ser una Activity. En mi implementación, al iniciar la clase, se añade un observador al ciclo de vida del Fragment. Cuando el Fragment ejecuta onDestroy(), se eliminan todos los observers de la lista y se elimina el propio observer del ciclo de vida.

Finalmente, para construir la clase, basta con llamarla así:

class HomeFragment : Fragment(), HomeContract.View {
    private lateinit var availableBalanceObservable: AvailableBalanceObservable<Double>
    // Resto del código...

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        // Resto del código...
        availableBalanceObservable = AvailableBalanceObservable(viewLifecycleOwner)
    }
}

Con estos dos cambios, la clase tiene más funcionalidades y está más cerca a la implementación de LiveData

Arquitectura

Patrones de Diseño en Android: Soluciones y Aplicación Práctica

Fundamentos de Arquitectura de Software y su Impacto en Proyectos

Arquitecturas en Android: MVC y MVVM

Desarrollo de una Billetera Virtual con Git y Android Studio

Arquitectura MVP: Modelo, Vista y Presentador en Desarrollo de Software

Arquitectura MVP: Implementación en Proyectos Android

Implementación de Arquitectura MVP en Android

Implementación de Loaders en Arquitectura MVP con Android

Arquitectura MVVM en Android: Comunicación entre Capas

Patrones de diseño

Patrones de Diseño en Android: Creacionales, Estructurales y Comportamiento

Patrones de diseño creacionales

Implementación del Patrón Singleton en Kotlin para Android

Patrón Singleton en Kotlin para Gestión de Estados en Android

Patrón Builder en Android: Creación de Objetos Complejos

Implementación del Patrón Builder en Clases de Usuario

Funciones de Alcance en Kotlin: Uso de Apply

Patrón Factory: Creación y Uso en Desarrollo de Software

Patrones de diseño estructurales

Patrón de Diseño Adaptador para Transformar Datos en Clases Java

Aplicación del Patrón Proxy en Transferencias Seguras

Patrón de Diseño Fast Add en Aplicaciones Android

Patrones de comportamiento

Patrones de Diseño: Implementación del Patrón Observer en Proyectos

Patrón Observer en Android: Implementación y Uso Práctico

Patrón Comando: Implementación y Gestión de Comandos en Kotlin

Comandos para Guardar y Leer Archivos en Android

Ejecución de Comandos y Debugging en Android Studio

Bonus: Architecture Components

Componentes de Android Jetpack para Mejora de Aplicaciones

Implementación de LiveData en Android para Ciclo de Vida

Implementación de Room en Android para Gestión de Base de Datos

Creación de Entidades y DAO en Base de Datos con Room en Kotlin

Conexión y manejo de transferencias en Room Database

Implementación de ViewModel en Arquitectura MVVM en Android

Bonus: Custom View

Creación de Vistas Personalizadas en Android con Custom View

Conclusiones

Patrones de Diseño y Componentes de Texto en Android

Patrón Observer en Android: Implementación y Uso Práctico