Modification de l'adaptation du client okhttp au moment de l'exécution

Question

fun getClient(token: String, userId: Long, language: String = "en", maxTry: Int = 2): Retrofit {
        val okHttpClient = OkHttpClient.Builder()
        okHttpClient.readTimeout(30, TimeUnit.SECONDS)
        okHttpClient.connectTimeout(30, TimeUnit.SECONDS)
        okHttpClient.writeTimeout(90, TimeUnit.SECONDS)
        var tryCount = 0
        okHttpClient.addInterceptor { chain ->
            val original = chain.request()
            val request = original.newBuilder()
                    .addHeader("Content-Type", "application/json")
                    .addHeader("secToken", token)
                    .addHeader("userId", userId.toString()).build()
            var response = chain.proceed(request)
            while (!response.isSuccessful && tryCount < maxTry) {
                Log.d("intercept", "Request is not successful - $tryCount")
                tryCount++
                response = chain.proceed(request)
            }
            response
        }

        val builder = GsonBuilder()
        builder.registerTypeAdapter(TransModel::class.java, NotificationTypeAdapter(language))
        val gson = builder.create()

        if (retrofit == null) {
            retrofit = Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .client(okHttpClient.build())
                    .build()
        } else {

        }

        //            .client(getHttpClientForFile())
        return retrofit!!
    }

Le code ci-dessus est pour obtenir un client rétrofit singleton pour chaque demande dans l'application.

Ce que je dois faire, c'est ce qu'il faut faire dans else part of retrofit == null.

Ici, la langue n'est initialisée qu'une seule fois. Lors de l'initialisation du rétrofit, mais pour la deuxième demande, je n'ai pas l'idée de changer la langue et le nombre d'essais maximum pour la demande.

Je veux changer de langue et de maxTry au moment de l'exécution. Pour chaque demande, il doit y avoir un nombre différent de maxTry et peut-être aussi une langue différente.

Edit : Selon la suggestion de @EarlOfEgo mon autre partie est

 retrofit!!.newBuilder().baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .client(okHttpClient.build())
                    .build()

mais il ne change pas de langue.

Edit 2 : TransModel

class TransModel {

    var en: String = ""
    var gu: String = ""
    var hi: String = ""

    constructor()

    fun get(language: String): String? {
        return when (language) {
            LanguageUtil.languageEn -> {
                en
            }

            LanguageUtil.languageGu -> {
                gu
            }

            LanguageUtil.languageHi -> {
                hi
            }

            else -> {
                null
            }
        }
    }

    constructor(language: String, value: String) {
        when (language) {
            LanguageUtil.languageEn -> {
                en = value
            }

            LanguageUtil.languageGu -> {
                gu = value
            }

            LanguageUtil.languageHi -> {
                hi = value
            }
        }
    }

    fun getValueByLanguage(language: String): String? {
        return when (language) {
            LanguageUtil.languageEn -> {
                en
            }

            LanguageUtil.languageGu -> {
                gu
            }

            LanguageUtil.languageHi -> {
                hi
            }

            else -> {
                null
            }
        }
    }

    fun updateIt(title: TransModel, currentLanguage: String) {
        when (currentLanguage) {
            LanguageUtil.languageEn -> {
                gu = title.gu
                hi = title.hi
            }

            LanguageUtil.languageGu -> {
                en = title.en
                hi = title.hi
            }

            LanguageUtil.languageHi -> {
                gu = title.gu
                en = title.en
            }

        }
    }
}

et mon NotificationTypeAdapter

class NotificationTypeAdapter(val language: String) : TypeAdapter<TransModel>() {
    override fun write(out: JsonWriter?, value: TransModel?) {
        if (out == null || value == null) return
        out.beginObject()
        out.name("title")
        out.value(value.getValueByLanguage(language))
        out.endObject()
    }

    override fun read(reader: JsonReader?): TransModel? {
        if (reader == null) return null
        val jsonParser = JsonParser()
        val je = jsonParser.parse(reader)
        val trans = TransModel(language, (je.asString))
        return trans
    }
}

Answer 1

Vous pouvez utiliser la méthode Retrofit nouveauConstructeur d'obtenir un nouveau constructeur et de mettre en place une autre OkHttpClient avec des attributs différents. Mettez quelque chose comme ceci dans votre else cas :

retrofit.newBuilder()
        .client(anotherOkHttpClientWithOtherAttributes.build())
        .build()

Answer 2

Comme je n'ai pas trouvé de réponse appropriée, j'utilise un nouveau client rétrofit pour chaque appel.

return Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .client(okHttpClient.build())
                .build()

Si quelqu'un a une réponse plus appropriée, veuillez me la suggérer.