Retrofit加kotlin协程为何如此优雅

interface AipInterface {

@GET("article/list/1/json")
fun getHomeList() : Call<WanBaseResponse<Data>>

}

val retrofit = Retrofit.Builder()
               .addConverterFactory(GsonConverterFactory.create())
               .baseUrl("https://www.wanandroid.com/")
               .build()
val service =  retrofit.create(AipInterface::class.java)
val call = service.getHomeList()
call.enqueue(object : Callback<WanBaseResponse<Data>> {
            override fun onFailure(call: Call<WanBaseResponse<Data>>, t: Throwable) {
                Log.i("CoroutinesActivity","onFailure")
            }

            override fun onResponse(call: Call<WanBaseResponse<Data>>, response: Response<WanBaseResponse<Data>>) {
                Log.i("CoroutinesActivity","onResponse:${response.body()}")
            }
        })

interface AipInterface {

    @GET("article/list/1/json")
    suspend  fun getHomeList() : WanBaseResponse<Data>
    
}

val retrofit = Retrofit.Builder()
               .addConverterFactory(GsonConverterFactory.create())
               .baseUrl("https://www.wanandroid.com/")
               .build()
val service =  retrofit.create(AipInterface::class.java)
GlobalScope.launch{
            val result = withContext(Dispatchers.IO){service.getHomeList()}
            Log.i("launch","onResponse:${result.data.datas[0].link}")
        }

class MyViewModel : ViewModel(){

    val mHomeData = MutableLiveData<Data>()

    fun launchOnUI(block:suspend CoroutineScope.()->Unit){
        viewModelScope.launch {
           withContext(Dispatchers.IO){ block()}
        }
    }
}

val myViewModel = ViewModelProvider(this).get(MyViewModel::class.java)
        myViewModel.launchOnUI{
            val result = service.getHomeList()
            Log.i("myViewModel","onResponse:${result.data.datas[0].link}")
    }

private const val JOB_KEY = "androidx.lifecycle.ViewModelCoroutineScope.JOB_KEY"

val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate))
        }

internal class CloseableCoroutineScope(context: CoroutineContext) : Closeable, CoroutineScope {
    override val coroutineContext: CoroutineContext = context

    override fun close() {
        coroutineContext.cancel()
    }
}

@MainThread
  final void clear() {
      mCleared = true;
      if (mBagOfTags != null) {
          synchronized (mBagOfTags) {
              for (Object value : mBagOfTags.values()) {
                  closeWithRuntimeException(value);
              }
          }
      }
      onCleared();
  }

private static void closeWithRuntimeException(Object obj) {
     if (obj instanceof Closeable) {
         try {
             ((Closeable) obj).close();
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
     }
 }

public <T> T create(final Class<T> service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
    eagerlyValidateMethods(service);
  }
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
      new InvocationHandler() {
        private final Platform platform = Platform.get();
        private final Object[] emptyArgs = new Object[0];

        @Override public @Nullable Object invoke(Object proxy, Method method,
            @Nullable Object[] args) throws Throwable {
          // If the method is a method from Object then defer to normal invocation.
          if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
          }
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
        }
      });
}

ServiceMethod<?> loadServiceMethod(Method method) {
  ServiceMethod<?> result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      result = ServiceMethod.parseAnnotations(this, method);
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

RequestFactory build() {

    for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
      
    ......

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
      }

    ......

      return new RequestFactory(this);
    }

suspend fun <T : Any> Call<T>.await(): T {
  return suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      cancel()
    }
    enqueue(object : Callback<T> {
      override fun onResponse(call: Call<T>, response: Response<T>) {
        if (response.isSuccessful) {
          val body = response.body()
          if (body == null) {
            val invocation = call.request().tag(Invocation::class.java)!!
            val method = invocation.method()
            val e = KotlinNullPointerException("Response from " +
                method.declaringClass.name +
                '.' +
                method.name +
                " was null but response body type was declared as non-null")
            continuation.resumeWithException(e)
          } else {
            continuation.resume(body)
          }
        } else {
          continuation.resumeWithException(HttpException(response))
        }
      }

      override fun onFailure(call: Call<T>, t: Throwable) {
        continuation.resumeWithException(t)
      }
    })
  }
}