web-dev-qa-db-ja.com

レトロフィット法をより表現力豊かに使用する

私はvoid enqueue(Callback<T> callback);メソッド呼び出しコードブロックをより表現力豊かにしたい、ここに私が通常持っているものがある

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

      override fun onResponse(call: Call<MyModel>?, response: Response<MyModel>?) {
           //
      }
 })
_

そして、私が望むと意味することは、このコードを変更してよりクリーンな方法をブロックし、それらを削除するオーバーライド、オブジェクト、コールバックキーワードとそのようなことをすることです：

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

拡張機能と高階関数を使用して、何らかの形で改善できると思います。誰もがそれをどのように行うことができるか知っていますか？

androidretrofitkotlinhigher-order-functions
29
Jemo Mgebrishvili

これは私が拡張機能とクラスでそれを行う方法です

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)
    }

}

次に、このように使用できます

request.enqueue {

    onResponse = {
        // do
    }

    onFailure = {
        // do
    }

}
27
codegames

次の関数を考えます：

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)
    }
}

これは、次のようにRetrofitで使用できます。

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

または、この他のバージョンのコールバックを定義できます：

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) }
    }
}


これは次のように使用できます。

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

あなたができることはこれです（これはJavaです）

public class CallbackWrapper<T> implements Callback<T> {
    private Wrapper<T> wrapper;

    public CallbackWrapper(Wrapper<T> wrapper) {
        this.wrapper = wrapper;
    }

    public void onFailure(Call<T> call, Throwable t) {
        wrapper.onResult(t, null);
    }

    public void onResponse(Call<T> call, Response<T> response) {
        wrapper.onResult(null, response);
    }

    public static interface Wrapper<T> {
        void onResult(Throwable t, Response<T> response);
    }
}

次のように使用できます：

call.enqueue(new CallbackWrapper((throwable, reponse) - > {...}));

kotlinのソリューションを更新：

this に基づいて、CallBackWrapperは次のようになります。

typealias wrapper<T> = (t: Throwable?, response: Response<T>?) -> Unit

class CallbackWrapper<T>(val wrapper: wrapper<T>) : Callback<T> {
   override fun onFailure(call: Call<T>?, t: Throwable?) = wrapper.invoke(t,null)
   override fun onResponse(call: Call<T>?, response: Response<T>?) = wrapper.invoke(null, response)
}

javaと同じように使用します。

6
njzk2

Callで拡張関数を使用して、表現力豊かで一般的なenqueueメソッドを記述しました。

fun<T> Call<T>.onEnqueue(actOnSuccess: (Response<T>) -> Unit, actOnFailure: (t: Throwable?) -> Unit)   {
    this.enqueue(object: Callback<T>    {
        override fun onFailure(call: Call<T>?, t: Throwable?) {
            actOnFailure(t)
        }

        override fun onResponse(call: Call<T>?, response: Response<T>) {
            actOnSuccess(response)
        }
    })
}

これは次のように使用できます。

request.onEnqueue    {
    actOnSuccess = {
        doOnSuccess()
    }
    actOnFailure = {
        doOnFailure()
    }
}

コードのactOnSuccessブロックとactOnFailureブロック内で、itはそれぞれResponseおよびThrowableオブジェクトを参照し、それに応じて活用できます。たとえば、actOnFailureコードブロック内では-

actOnFailure = {
        doOnFailure()
        //it.message //'it' refers to the Throwable object.
    }
5
Supriya

このような拡張関数を作成できます

inline fun <T> Call<T>.addEnqueue(
    crossinline onSuccess: (response: Response<T>) -> Unit = { response: Response<T> -> },
    crossinline onFail: (t: Throwable) -> Unit = { throwable: Throwable ->}
):Callback<T> {
    val callback = object : Callback<T> {
        override fun onFailure(call: Call<T>, t: Throwable) {
            onFail(t)
        }

        override fun onResponse(call: Call<T>, response: Response<T>) {
            onSuccess(response)
        }
    }
    enqueue(callback)
    return callback
}

アクティビティまたはフラグメントでこのように使用します

 service?.fetchUser()?.addEnqueue(
            onSuccess = {
                doOnSuccess(it)
            },
            onFail = {
                doOnFail(it)
            }
    )
1
Ashutosh