Android LiveData на Kotlin с использованием Retrofit и coroutines

import android.arch.lifecycle.MutableLiveData import android.util.Log import com.jakewharton.retrofit2.adapter.kotlin.coroutines.experimental.CoroutineCallAdapterFactory import kotlinx.coroutines.experimental.android.UI import kotlinx.coroutines.experimental.async import retrofit2.Retrofit import retrofit2.converter.gson.GsonConverterFactory import okhttp3.OkHttpClient import okhttp3.logging.HttpLoggingInterceptor import retrofit2.Call import retrofit2.http.* import ru.gildor.coroutines.retrofit.Result import ru.gildor.coroutines.retrofit.awaitResult  object ServerAPI {      var API_BASE_URL: String = getNetworkHost();     var httpClient = OkHttpClient.Builder().addInterceptor(         HttpLoggingInterceptor().apply {             level = if (BuildConfig.DEBUG) HttpLoggingInterceptor.Level.BODY else HttpLoggingInterceptor.Level.NONE         })      var builder: Retrofit.Builder = Retrofit.Builder()             .baseUrl(API_BASE_URL)             .addCallAdapterFactory(CoroutineCallAdapterFactory())             .addConverterFactory(GsonConverterFactory.create())      var retrofit = builder             .client(httpClient.build())             .build()      var netService = retrofit.create<NetService>(         NetService::class.java!!)      interface NetService {         @GET("api/stores")         fun getStoreAll(@Header("Authorization") bearer: String): Call<Array<Store>>     } } 

   class Repository {      fun getStores(token: String)  :  MutableLiveData<Resource<Array<Store>>>{         val mutableLiveData = MutableLiveData<Resource<Array<Store>>>()         mutableLiveData.value = Resource.loading(null)         val req = PostsAPI.netService.getStoreAll(token)          try {             async(UI) {                 val result = req.awaitResult()                 // Check result type                 when (result) {                     //Successful HTTP result                     is Result.Ok -> {                         mutableLiveData.value = Resource.success(result.value)                     }                     // Any HTTP error                     is Result.Error -> {                         mutableLiveData.value  = Resource.error("Http Error!", null)                     }                     // Exception while request invocation                     is Result.Exception -> Log.d(TAG, result.exception.message)                 }             }         } catch (e: Exception) {             Log.d(TAG, e.toString())         }         return mutableLiveData     } }      

// A generic class that contains data and status about loading this data. public class Resource<T> {     @NonNull public final Status status;     @Nullable public final T data;     @Nullable public final String message;     private Resource(@NonNull Status status, @Nullable T data,             @Nullable String message) {         this.status = status;         this.data = data;         this.message = message;     }      public static <T> Resource<T> success(@NonNull T data) {         return new Resource<>(Status.SUCCESS, data, null);     }      public static <T> Resource<T> error(String msg, @Nullable T data) {         return new Resource<>(Status.ERROR, data, msg);     }      public static <T> Resource<T> loading(@Nullable T data) {         return new Resource<>(Status.LOADING, data, null);     }      public enum Status { SUCCESS, ERROR, LOADING } }       

class StoresViewModel (context: Context, token: String) : ViewModel() {     val stores: MutableLiveData<Resource<Array<Store>>>     init {         val api = Repository()         stores = api.getStores(token)     } }       

class AppViewModelFactory(private val contect: Context, vararg params: Any) :     ViewModelProvider.NewInstanceFactory() {     private val mParams: Array<out Any>      init {         mParams = params     }      override fun <T : ViewModel> create(modelClass: Class<T>): T {         return if (modelClass == LoginViewModel::class.java) {             LoginViewModel(contect, mParams[0] as String, mParams[1] as String) as T         } else if (modelClass == StoresViewModel::class.java) {             StoresViewModel(contect, mParams[0] as String) as T         } else {             super.create(modelClass)         }     } }       

    override fun onCreateView(         inflater: LayoutInflater, container: ViewGroup?,         savedInstanceState: Bundle?     ): View? {         val view = inflater.inflate(R.layout.stores_fragment, container, false)          val tokenHolder = TokenHolder(PreferenceManager.getDefaultSharedPreferences(requireActivity()))          viewModel = ViewModelProviders.of(this, AppViewModelFactory(requireActivity(), tokenHolder.token)).get(StoresViewModel::class.java)          recyclerView = view.findViewById<RecyclerView>(R.id.store_list).apply {             setHasFixedSize(true)         }         return view     }       override fun onActivityCreated(savedInstanceState: Bundle?) {         super.onActivityCreated(savedInstanceState)          // Observe data on the ViewModel, exposed as a LiveData         viewModel.stores.observe(this, Observer<Resource<Array<Store>>> { storesResource ->              val stores = storesResource?.data             stores?.let {                 viewAdapter = StoresAdapter(stores!!)                 recyclerView.adapter = viewAdapter             }              if (storesResource?.status  == Resource.LOADING){                 log("Loading...")             }              if (storesResource?.status  == Resource.ERROR){                 log("Error : " + storesResource?.message)             }          })     }