coroutines.kt

 suspend fun <ResponseType>
            makeCall(deferredResponse: Deferred<Response<ResponseType>>): LiveData<Resource<ResponseType>> {

        val result = MutableLiveData<Resource<ResponseType>>()


        try {
            val response = deferredResponse.await()

            if (response.isSuccessful) {
                withContext(Dispatchers.Main) {
                    result.postValue(Resource(Status.SUCCESS, response.body(), response.message()))
                }
            }
            else {
                withContext(Dispatchers.Main){
                    result.postValue(Resource(Status.ERROR, response.body(), response.errorBody()?.string(), response.code()))
                }
            }
        }
        catch (e : Exception) {
            result.postValue(Resource(Status.ERROR, null, "An network err"))
        }

        return result

    }

    suspend fun updateDriverProfile(data : DriverProfileSignUpBody) : LiveData<Resource<DriverProfile>>{
        return makeCall(service.updateDriverProfile(data, "staging", true ))
    }

    @POST("/editDriverProfile")
    fun updateDriverProfile(@Body body : DriverProfileSignUpBody, @Header("ENVIRONMENT") environment : String,
                            @Header("AUTH") takesAuth : Boolean) : Deferred<Response<DriverProfile>>

private val okHttpClient by lazy {
        providesOkHttpClient()
    }

    private val briumRetrofit by lazy {
        providesRetrofit(okHttpClient, "https://us-central1-briumapp.cloudfunctions.net/")
    }

    val googleApiService by lazy {
        providesApiService(briumRetrofit)
    }

    private fun providesOkHttpClient(): OkHttpClient {
        return OkHttpClient.Builder()
            .readTimeout(3, TimeUnit.MINUTES)
            .writeTimeout(3, TimeUnit.MINUTES)
            .connectTimeout(3, TimeUnit.MINUTES)
            .apply {
                //                    if (!BuildConfig.BUILD_TYPE.contains("release")) {
                val logging = HttpLoggingInterceptor()
                logging.level = HttpLoggingInterceptor.Level.BODY
                addNetworkInterceptor(logging)


            }
            .addNetworkInterceptor(TokenInterceptor())
            .build()
    }

    private fun providesRetrofit(okHttpClient: OkHttpClient, baseUrl : String): Retrofit {

        return Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create(GsonBuilder().create()))
            .addCallAdapterFactory(CoroutineCallAdapterFactory())
            .build()
    }

    private fun providesApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }

viewModelScope.launch(Dispatchers.Main) {
            val result = networkRepo.requestRide(body)


            rideRequestSubmittedLd.addSource(result) {
                it?.let {
                    findingRideProgressLd.value = false

                    when (it.status) {
                        Status.SUCCESS -> {
                            it.data?.let {
                                sharedPrefsRepo.saveRideRequestReponse(it)
                                rideRequestSubmittedLd.value = true
                                findingRideProgressLd.value = true

                                listenForDrivers(it)
                            }
                        }
                        Status.ERROR -> {
                            toastLd.value = it.message
                        }
                        else -> {
                        }
                    }
                }
            }
        }