Use Retrofit methods more expressive way

Question

I want to make void enqueue(Callback<T> callback); method invocation code block more expressive, Here is what I have an usually

request.enqueue(object : Callback<MyModel> {       override fun onFailure(call: Call<MyModel>?, t: Throwable?) {            //       }        override fun onResponse(call: Call<MyModel>?, response: Response<MyModel>?) {            //       }  }) 

And what I want and mean is that, to change this code blocks more cleaner way and remove those override, object, Callback keywords and do something like that:

request.enqueue({throwable, response -> })

I think it could be improved somehow using extensions and higher-order functions. Does anyone know how it can be done?

Answer 1

this is how i do it with extension function and a class

fun<T> Call<T>.enqueue(callback: CallBackKt<T>.() -> Unit) {     val callBackKt = CallBackKt<T>()     callback.invoke(callBackKt)     this.enqueue(callBackKt) }  class CallBackKt<T>: Callback<T> {      var onResponse: ((Response<T>) -> Unit)? = null     var onFailure: ((t: Throwable?) -> Unit)? = null      override fun onFailure(call: Call<T>, t: Throwable) {         onFailure?.invoke(t)     }      override fun onResponse(call: Call<T>, response: Response<T>) {         onResponse?.invoke(response)     }  } 

then you can use it like this

request.enqueue {      onResponse = {         // do     }      onFailure = {         // do     }  } 

Answer 2

Given the following function:

fun <T> callback(fn: (Throwable?, Response<T>?) -> Unit): Callback<T> {     return object : Callback<T> {         override fun onResponse(call: Call<T>, response: retrofit2.Response<T>) = fn(null, response)         override fun onFailure(call: Call<T>, t: Throwable) = fn(t, null)     } } 

You can use this with Retrofit like this:

request.enqueue(callback({ throwable, response ->  response?.let { callBack.onResponse(response.body() ?: RegisterResponse()) }  throwable?.let { callBack.onFailed(throwable.message!!) }) 

Alternately, you can define this other version of callback:

fun <T> callback2(success: ((Response<T>) -> Unit)?, failure: ((t: Throwable) -> Unit)? = null): Callback<T> {     return object : Callback<T> {         override fun onResponse(call: Call<T>, response: retrofit2.Response<T>) { success?.invoke(response) }         override fun onFailure(call: Call<T>, t: Throwable) { failure?.invoke(t) }     } } 

which can be used like this:

request.enqueue(callback2(                 { r -> callBack.onResponse(r.body()) },                 { t -> callBack.onFailed(t.message) }))