Comment j'ai fait un disjoncteur Okhttp personnalisé à travers les coroutines de Kotlin

Commençons par l'énoncé du problème.

1. Il est nécessaire d'envoyer le jeton et l'ID utilisateur dans chaque demande dans l'en-tête
2. Il est nécessaire de tirer de chaque réponse un nouveau jeton et un nouvel identifiant d'utilisateur à partir des en-têtes
3. Les données reçues doivent être enregistrées.

La bibliothèque pour l'interaction avec le serveur est Retrofit. Les coroutines sont responsables du multithreading.
La tâche n'est pas difficile, il vous suffit d'ajouter le disjoncteur client Okhttp à chaque requête. Une demi-heure et tout est prêt, tout fonctionne, tout le monde est content. Mais je me demandais, est-il possible de faire un disjoncteur sans client Okhttp?

Commençons par résoudre les problèmes dans l'ordre. S'il n'y a pas de problème avec l'ajout d'en-tête (il vous suffit d'ajouter @HeaderMap dans la demande), alors comment obtenir les en-têtes qui viennent dans la réponse? Très simple, nous devons encapsuler notre réponse dans la classe Response, qui a une méthode headers ().

Voici l'interface de requête:

@FormUrlEncoded @POST("someurl/") suspend fun request1(@Field("idLast") idLastFeed: Long, @Field("autoview") autoView: Boolean, @HeaderMap headers: Map<String, String?>): Answer1 @FormUrlEncoded @POST("someurl/") suspend fun request2(@Field("ransom") ransom: Long, @HeaderMap headers: Map<String, String?>): Answer2 

Mais cela est devenu:

 @FormUrlEncoded @POST("someurl") suspend fun request1(@Field("idLast") idLastFeed: Long, @Field("autoview") autoView: Boolean, @HeaderMap headers: Map<String, String?>?): Response<Answer1> @FormUrlEncoded @POST("someurl") suspend fun request2(@Field("ransom") ransom: Long, @HeaderMap headers: Map<String, String?>?): Response<Answer2> 

Maintenant, pour chaque demande, vous devez ajouter le paramètre headersMap. Créons une classe RestClient distincte pour le shell de requête afin que le jeton et l'ID ne soient pas extraits constamment de sharedPreferences dans le présentateur. Voici comment cela se révèle:

 class RestClient(private val api: Api, private val prefs: SharedPreferences) { suspend fun request1(last: Long, autoView: Boolean): Answer1 { return api.request1(last, autoView, headers()) } suspend fun request2(id: Long): Answer2 { return api.request2(id, headers()) } private val TOKEN_KEY = "Token" private val ID_KEY = "ID" fun headers(): Map<String, String> { return mapOf( TOKEN_KEY to prefs.getString(Constants.Preferences.SP_TOKEN_KEY, ""), ID_KEY to prefs.getLong(Constants.Preferences.SP_ID, -1).toString() ) } } 

On voit que nous faisons la même chose:

1. Nous obtenons quelques paramètres pour la demande.
2. Ajoutez des en-têtes à la demande.
3. Appelez la méthode.
4. Nous obtenons de nouvelles valeurs des en-têtes.
5. Nous retournons le résultat.

Pourquoi ne faisons-nous pas une seule fonction pour toutes les demandes? Pour ce faire, modifiez les requêtes. Au lieu de variables individuelles de type @Field, nous allons maintenant utiliser @FieldMap. Ce sera le premier paramètre de notre fonction - le percher. Le deuxième paramètre que nous aurons est la requête elle-même. Ici, j'ai utilisé Kotlin DSL (je voulais vraiment). J'ai créé la classe Request dans laquelle j'ai créé la fonction send pour appeler la requête.

Voici à quoi ressemble l'interface de requête:

 @FormUrlEncoded @POST("someurl/") suspend fun feedListMap(@FieldMap map: HashMap<String, out Any>?, @HeaderMap headers: Map<String, String?>?): Response<Answer1> @FormUrlEncoded @POST("someurl/") suspend fun feedListMap(@FieldMap map: HashMap<String, out Any>?, @HeaderMap headers: Map<String, String?>?): Response<Answer2> 

Et voici la classe Request:

 class Request<T>( var fieldHashMap: java.util.HashMap<String, out Any> = hashMapOf(), var headersHashMap: Map<String, String?>? = mapOf(), var req: suspend (HashMap<String, out Any>?, Map<String, String?>?) -> Response<T>? = { _,_ -> null} ){ fun send(): Response<T>? { return runBlocking { try { req.invoke(fieldHashMap, headersHashMap) } catch (e: Exception) { throw Exception(e.message ?: " ") } catch (t: Throwable) { throw Exception(t.message ?: " ") } } } } 

Maintenant, la classe RestClient ressemble à ceci:

 class RestClient(private val api: Api, private val prefs: SharedPreferences) { private val TOKEN_KEY = "Token" private val ID_KEY = "ID" fun headers(): Map<String, String> { return mapOf( TOKEN_KEY to prefs.getString(Constants.Preferences.SP_TOKEN_KEY, ""), ID_KEY to prefs.getLong(Constants.Preferences.SP_ID, -1).toString() ) } fun <T> buildRequest(request: Request<T>.() -> Unit): T? { val req = Request<T>() request(req) val res = req.send() val newToken = res?.headers()?.get(TOKEN_KEY) val newID = res?.headers()?.get(ID_KEY)?.toLong() if (newToken.notNull() && newID.notNull()) { prefs.edit() .putString(TOKEN_KEY, newToken) .putLong(ID_KEY, newID) .apply() } return res?.body() } fun fiedsMapForRequest1(last: Long, autoView: Boolean) = hashMapOf("idLast" to last, "autoview" to autoView) fun fiedsMapForRequest2(ransom: Long, autoView: Boolean) = hashMapOf("ransom" to ransom) } 

Et enfin, voici comment nous appelons nos demandes dans le présentateur:

 try { val answer1 = restClient.buildRequest<Answer1> { fieldHashMap = restClient.fiedsMapForRequest1(1, false) headersHashMap = restClient.headers() req = api::request1 } val answer2 = restClient.buildRequest<Answer2> { fieldHashMap = restClient.fiedsMapForRequest2(1234) headersHashMap = restClient.headers() req = api::request2 } // do something with answer } catch (e: Exception) { viewState.showError(e.message.toString()) } finally { viewState.hideProgress() } 

Ici, j'ai fait un disjoncteur personnalisé avec l'aide de Kotlin.

PS La solution à ce problème était très excitante, mais, malheureusement, le projet utilise un disjoncteur Okhttp.