Using Sealed class and LiveData to handle network request through the repository layer.

CartManager.kt

/**
 * Observable manager for saving the [Cart]'s resource information.
 */
class CartManager : LiveData<Resource<Cart?>>() {

  init {
    value = Success(null)
  }

  /**
   * Set the [Cart] value and notifies observers.
   */
  internal fun set(cart: Cart) {
    postValue(Success(cart))
  }

  /**
   * Clear any information from the device.
   */
  internal fun clear() {
    postValue(Success(null))
  }

  /**
   * Signals that the resource information is being retrieved from network.
   */
  internal fun loading() {
    postValue(Loading())
  }

  /**
   * Signals that an error occurred when trying to fetch the resource information.
   */
  internal fun error(t: Throwable) {
    postValue(Failure(t))
  }
}

CartRepository.kt

/**
 * [Cart] repository class in charge of providing api for getting and updating a [Cart] data.
 */
class CartRepository(private val service: RetrofitApi, private val cartManager: CartManager) {

  fun getCartResource(): LiveData<Resource<Cart?>> = cartManager

  /**
   * Get a [Cart].
   */
  suspend fun get() {
    withContext(Dispatchers.IO) {
      try {
        cartManager.loading()

        val cart = service.getCart().await()

        cartManager.set(cart)
      } catch (e: Exception) {
        cartManager.error(e)
      }
    }
  }

  /**
   * Add a [Cart] shipping information.
   */
  suspend fun addShippingAddress(shipping: ShippingAddress) {
    withContext(Dispatchers.IO) {
      try {
        cartManager.loading()

        val cart = service.addShippingAddress(shipping).await()

        cartManager.set(cart)
      } catch (e: Exception) {
        cartManager.error(e)
      }
    }
  }
}

CheckoutActivity.kt

class CheckoutActivity : AppCompatActivity() {

 private lateinit var vm: CheckoutViewModel

 override fun onCreate(savedInstanceState: Bundle?) {
   // Initialization
   ...
   vm.cart.observe(this, Observer { resource ->
     when (resource) {
       is Loading -> showLoading()
       is Success -> {
         displayCart(resource.data) // Do something with your data.
         hideLoading()
       }
       is Failure -> {
         showError(resource.throwable) // Do something with your error.
         hideLoading()
       }
   })
 }
}

CheckoutViewModel.kt

class CheckoutViewModel(repo: CartRepository) : ViewModel() {
  /**
   * Live data for [Cart] information.
   */
  val cart: LiveData<Resource<Cart?>> = repo.getCartResource()
}

Resource.kt

/**
 * Represents a network bound resource. Each subclass represents the resource's state:
 * - [Loading]: the resource is being retrieved from network.
 * - [Success]: the resource has been retrieved (available in [Success.data] field)
 * - [Failure]: the resource retrieving has failed (throwable available in [Failure.throwable] field)
 */
sealed class Resource<out T> {
  class Loading<out T> : Resource<T>()
  data class Success<out T>(val data: T) : Resource<T>()
  data class Failure<out T>(val throwable: Throwable) : Resource<T>()
}

What if you're integrating a database layer? Would we still be observing the resource in the UI if you want to fetched cached objects?