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

Clase 21 de 32 • Curso de Patrones de Diseño en Android

Resumen

¿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.