Ejemplo en Código:

Creamos una nueva clase en nuestro paquete de observable

• AvailableBalanceObservable: Esta clase se encargara de manejar los eventos del saldo disponible, y en esta vamos a implementar la interfaz de Observable

  class AvailableBalanceObservable : Observable {
      private val amountObserverList: ArrayList<Observer> = arrayListOf() // Lista de observadores
      private var amount: Double = 0.0
  
      fun changeAmount(newValue: Double) {
          // Este sera nuestro punto de entrada para ir cambiando el valor de manera reactiva
          amount = newValue
          notifyObserver(newValue)
      }
  
      override fun addObserver(observer: Observer) {
          // En este metodo nos subscribimos
          amountObserverList.add(observer)
      }
  
      override fun removeObserver(observer: Observer) {
          // En este metodo nos desubscribimos
          amountObserverList.remove(observer)
      }
  
      override fun notifyObserver(newValue: Double) {
          // En este notificamos a todos los observers para que se actualicen con el nuevo valor
          amountObserverList.forEach {
              it.notifyChange(newValue)
          }
      }
  
  }
  

En el HomeFragment agregamos la instancia

class HomeFragment : Fragment(), HomeContract.View {

	// ...
	
	private  val availableBalanceObservable = AvailableBalanceObservable()
	
	// ...

	**override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
	
	        // ...
	
	        availableBalanceObservable.addObserver(object: Observer {
	            override fun notifyChange(newValue: Double) {
	                amountValueTextView.text = "$ $newValue"
	            }
	        })
	    }

	// ...

}**

A tener en cuenta

El observador y lo observable son dos entidades que necesitan comunicarse, y debemos gestionarlos de dos maneras diferentes. Cuando me suscribo, también es necesario que elimine la suscripción.

En Android, el ciclo de vida es bastante volátil. Es una buena práctica suscribirse cuando una actividad está a punto de destruirse, ya que si intento notificar a ese observador después de que la actividad ya no exista, se producirá un error.

Es fundamental tener en cuenta que estas dos interfaces están en constante comunicación. En Android, nuestras actividades siguen un ciclo de vida. Al llegar al método onDestroy, es muy recomendable suscribirse a todos los eventos del observador. Esto es importante porque si el observador emite un evento cuando la actividad ya no está en pantalla, se generará una excepción de puntero nulo.

También es importante tener en cuenta que los observadores y el observador tienen un tipo de dato. Podemos personalizar este tipo de dato utilizando genéricos, lo que asegura que estas interfaces no solo sirvan para el tipo de dato 'double' que estamos utilizando en el proyecto.

Te invito a ser muy cauteloso y entender cómo implementar esto, ya que la librería 'Reactive Tests' se basa en este patrón de comportamiento.