Android LiveData on Kotlin using Retrofit and 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!!)interfaceNetService{
        @GET("api/stores")fungetStoreAll(@Header("Authorization") bearer: String): Call<Array<Store>>
    }
}

classRepository{
    fungetStores(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 typewhen (result) {
                    //Successful HTTP resultis Result.Ok -> {
                        mutableLiveData.value = Resource.success(result.value)
                    }
                    // Any HTTP erroris Result.Error -> {
                        mutableLiveData.value  = Resource.error("Http Error!", null)
                    }
                    // Exception while request invocationis 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.publicclassResource<T> {
    @NonNullpublicfinal Status status;
    @Nullablepublicfinal T data;
    @Nullablepublicfinal String message;
    privateResource(@NonNull Status status, @Nullable T data,
            @Nullable String message){
        this.status = status;
        this.data = data;
        this.message = message;
    }
    publicstatic <T> Resource<T> success(@NonNull T data){
        returnnew Resource<>(Status.SUCCESS, data, null);
    }
    publicstatic <T> Resource<T> error(String msg, @Nullable T data){
        returnnew Resource<>(Status.ERROR, data, msg);
    }
    publicstatic <T> Resource<T> loading(@Nullable T data){
        returnnew Resource<>(Status.LOADING, data, null);
    }
    publicenum Status { SUCCESS, ERROR, LOADING }
}
      

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

classAppViewModelFactory(privateval contect: Context, vararg params: Any) :
    ViewModelProvider.NewInstanceFactory() {
    privateval mParams: Array<out Any>
    init {
        mParams = params
    }
    overridefun<T : ViewModel>create(modelClass: Class<T>): T {
        returnif (modelClass == LoginViewModel::class.java) {
            LoginViewModel(contect, mParams[0] as String, mParams[1] as String) as T
        } elseif (modelClass == StoresViewModel::class.java) {
            StoresViewModel(contect, mParams[0] as String) as T
        } else {
            super.create(modelClass)
        }
    }
}
      

overridefunonCreateView(
        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
    }
    overridefunonActivityCreated(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)
            }
        })
    }