💇🏻 🛂 ㊙️ Expérience avec Coroutines et Retrofit2 🕗 👨🏼‍🔧 🍢

Qu'est ce que c'est

Qui n'a pas encore lu la documentation - je vous recommande fortement de vous familiariser.

Ce que Jetbrain écrit:

Les coroutines simplifient la programmation asynchrone, laissant toutes les complications à l'intérieur des bibliothèques. La logique du programme peut être exprimée séquentiellement en coroutines, et la bibliothèque de base l'implémentera de manière asynchrone pour nous. La bibliothèque peut encapsuler les parties correspondantes du code utilisateur dans des rappels souscrivant aux événements correspondants et envoyer l'exécution à différents threads (ou même à différentes machines!). Le code restera aussi simple que s'il était exécuté strictement séquentiellement.

En termes simples, il s'agit d'une bibliothèque pour l'exécution de code synchrone / asynchrone.

Pourquoi?

Parce que RxJava n'est plus à la mode (je plaisante).

Premièrement, je voulais essayer quelque chose de nouveau, et deuxièmement, je suis tombé sur un article - une comparaison de la vitesse de la corutine et d'autres méthodes.

Exemple

Par exemple, vous devez effectuer une opération en arrière-plan.

Pour commencer - ajoutez à notre dépendance build.gradle à la corutine:

dependencies {
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
....
}

view raw build.gradle hosted with ❤ by GitHub

Nous utilisons la méthode dans notre code:

suspend fun <T> withContext(
context: CoroutineContext,
block: suspend CoroutineScope.() -> T
)

view raw gistfile1.txt hosted with ❤ by GitHub

Où dans le contexte - nous spécifions le pool de threads dont nous avons besoin - dans les cas simples, ce sont IO, Main et Default

IO - pour les opérations simples avec l'API, les opérations avec la base de données, les préférences partagées, etc.
Principal - Fil d'interface utilisateur, d'où nous pouvons accéder à la vue
Par défaut - pour les opérations lourdes avec une charge CPU élevée
(Plus dans cet article )

Block - le lambda que nous voulons exécuter

var result = 1.0
withContext(IO) {
for (i in 1..1000) {
result += i * i
}
}
Log.d("coroutines example", "result = $result")

view raw Example.kt hosted with ❤ by GitHub

En principe, c'est tout, nous obtenons le résultat de la somme des carrés de 1 à 1000 et en même temps nous ne bloquons pas le thread principal, ce qui signifie pas d'ANR

Cependant, si notre coroutine est exécutée pendant 20 secondes et pendant ce temps, nous avons effectué 2 tours de l'appareil, nous aurons alors 3 blocs en cours d'exécution. Oups

Et si nous passions un lien vers l'activité vers le bloc - une fuite et le manque de capacité à effectuer des opérations avec vue dans les anciens blocs. Oups deux fois.

Alors que faire?

Faire mieux

private var viewModelJob = Job()
private val viewModelScope = CoroutineScope(Dispatchers.Main + viewModelJob)
fun doWork() {
var result = 1.0
viewModelScope.launch {
withContext(IO) {
for (i in 1..1000) {
result += i * i
}
}
}
Log.d("coroutines example", " result = $result")
}
fun cancelJob() {
viewModelJob.cancel()
}

view raw Example.kt hosted with ❤ by GitHub

Ainsi, nous avons pu arrêter l'exécution de notre code dans le flux, par exemple, lorsque l'écran est tourné.

CoroutineScope a permis de combiner la portée de toutes les coroutines imbriquées et, lors de l'appel de job.cancel (), a arrêté leur exécution

Si vous prévoyez de réutiliser la portée après l'arrêt de l'exécution, vous devez utiliser job.cancelChildren () au lieu de job.cancel () merci Neikist pour le commentaire

Dans le même temps, nous avons encore la possibilité de contrôler les flux:

fun doWork() {
var result = 1.0
var result2 = 1.0
viewModelScope.launch {
withContext(IO) {
for (i in 1..1000) {
result += i * i
}
}
withContext(Default) {
for (i in 1..1000) {
result2 += i * i
}
}
}
Log.d("coroutines example", "running result = $result, result 2 = $result2")
}
fun cancelJob() {
viewModelJob.cancel()
}

view raw Example.kt hosted with ❤ by GitHub

Nous connectons retrofit2

Ajoutez des dépendances à la grêle:

dependencies {
implementation "com.squareup.retrofit2:retrofit:$retrofitVersion"
implementation "com.squareup.retrofit2:converter-moshi:$converterMoshiVersion"
implementation "com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:$retrofitCoroutinesVersion"
...
}

view raw build.gradle hosted with ❤ by GitHub

Nous utilisons le stylet https://my-json-server.typicode.com/typicode/demo/posts comme exemple

Nous décrivons l'interface de retrofit:

interface RetrofitPosts {
@GET("posts")
fun getPosts(): Deferred<Response<List<Post>>>
}

view raw RetrofitPosts.kt hosted with ❤ by GitHub

Décrivez le modèle de message retourné:

data class Post(val id: Int, val title: String)

view raw Post.kt hosted with ❤ by GitHub

Notre référentiel de base:

abstract class BaseRepository<Params, Result> {
abstract suspend fun doWork(params: Params): Result
}

view raw BaseRepository.kt hosted with ❤ by GitHub

Implémentation de PostsRepository:

class PostsRepository :
BaseRepository<PostsRepository.Params, PostsRepository.Result>() {
override suspend fun doWork(params: Params): Result {
val retrofitPosts = Retrofit
.Builder()
.baseUrl("https://jsonplaceholder.typicode.com")
.addConverterFactory(MoshiConverterFactory.create())
.addCallAdapterFactory(CoroutineCallAdapterFactory())
.build()
.create(RetrofitPosts::class.java)
val result = retrofitPosts
.getPosts()
.await()
return Result(result.body())
}
class Params
data class Result(val posts: List<Post>?)
}

view raw PostsRepository.kt hosted with ❤ by GitHub

Notre BaseUseCase:

abstract class BaseUseCase<Params, Result> {
abstract suspend fun doWork(params: Params): Result
}

view raw BaseUseCase.kt hosted with ❤ by GitHub

Implémentation de GetPostsListUseCase:

class GetListOfPostsUseCase
: BaseUseCase<GetListOfPostsUseCase.Params, GetListOfPostsUseCase.Result>() {
override suspend fun doWork(params: Params): Result {
return Result(
PostsRepository()
.doWork(PostsRepository.Params())
.response
.posts
)
}
class Params
class Result(val posts: List<Post>?)
}

view raw GetListOfPostsUseCase.kt hosted with ❤ by GitHub

Voici le résultat:

fun doWork() {
val useCase = GetListOfPostsUseCase()
viewModelScope.launch {
withContext(Dispatchers.IO) {
val result = useCase.doWork(
GetListOfPostsUseCase.Params()
)
Log.d("coroutines example", "get list of posts = ${result.posts}")
}
}
}
fun cancelJob() {
viewModelJob.cancel()
}

view raw Example.kt hosted with ❤ by GitHub

Le rendre meilleur

Je suis une créature paresseuse et chaque fois que je ne veux pas faire glisser toute la feuille de code, j'ai donc fait les méthodes nécessaires dans BaseViewModel:

abstract class BaseViewModel : ViewModel() {
private var viewModelJob = Job()
private val viewModelScope = CoroutineScope(Dispatchers.Main + viewModelJob)
private var isActive = true
// Do work in IO
fun <P> doWork(doOnAsyncBlock: suspend CoroutineScope.() -> P) {
doCoroutineWork(doOnAsyncBlock, viewModelScope, IO)
}
// Do work in Main
// doWorkInMainThread {...}
fun <P> doWorkInMainThread(doOnAsyncBlock: suspend CoroutineScope.() -> P) {
doCoroutineWork(doOnAsyncBlock, viewModelScope, Main)
}
// Do work in IO repeately
// doRepeatWork(1000) {...}
// then we need to stop it calling stopRepeatWork()
fun <P> doRepeatWork(delay: Long, doOnAsyncBlock: suspend CoroutineScope.() -> P) {
isActive = true
viewModelScope.launch {
while (this@BaseViewModel.isActive) {
withContext(IO) {
doOnAsyncBlock.invoke(this)
}
if (this@BaseViewModel.isActive) {
delay(delay)
}
}
}
}
fun stopRepeatWork() {
isActive = false
}
override fun onCleared() {
super.onCleared()
isActive = false
viewModelJob.cancel()
}
private inline fun <P> doCoroutineWork(
crossinline doOnAsyncBlock: suspend CoroutineScope.() -> P,
coroutineScope: CoroutineScope,
context: CoroutineContext
) {
coroutineScope.launch {
withContext(context) {
doOnAsyncBlock.invoke(this)
}
}
}
}

view raw BaseViewModel.kt hosted with ❤ by GitHub

Maintenant, la liste des messages ressemble à ceci:

class PostViewModel : BaseViewModel() {
val lengthOfPostsList = MutableLiveData<String>()
fun getListOfPosts() {
doWork {
val result = GetListOfPostsUseCase()
.doWork(GetListOfPostsUseCase.Params())
Log.d("coroutines example", "get list of posts = ${result.posts}")
lengthOfPostsList.postValue(result.posts?.size.toString())
}
}

view raw PostViewModel.kt hosted with ❤ by GitHub

Conclusion

J'ai utilisé des coroutines dans la prod et le code s'est avéré vraiment plus propre et plus lisible.

UPD:
Retrofit exception handling description see comment

	dependencies {
	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
	....
	}

	suspend fun <T> withContext(
	context: CoroutineContext,
	block: suspend CoroutineScope.() -> T
	)

	var result = 1.0
	withContext(IO) {
	for (i in 1..1000) {
	result += i * i
	}
	}
	Log.d("coroutines example", "result = $result")

	private var viewModelJob = Job()
	private val viewModelScope = CoroutineScope(Dispatchers.Main + viewModelJob)

	fun doWork() {
	var result = 1.0
	viewModelScope.launch {
	withContext(IO) {
	for (i in 1..1000) {
	result += i * i
	}
	}
	}
	Log.d("coroutines example", " result = $result")
	}

	fun cancelJob() {
	viewModelJob.cancel()
	}

	fun doWork() {
	var result = 1.0
	var result2 = 1.0
	viewModelScope.launch {
	withContext(IO) {
	for (i in 1..1000) {
	result += i * i
	}
	}
	withContext(Default) {
	for (i in 1..1000) {
	result2 += i * i
	}
	}
	}
	Log.d("coroutines example", "running result = $result, result 2 = $result2")
	}

	fun cancelJob() {
	viewModelJob.cancel()
	}


	dependencies {
	implementation "com.squareup.retrofit2:retrofit:$retrofitVersion"
	implementation "com.squareup.retrofit2:converter-moshi:$converterMoshiVersion"
	implementation "com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:$retrofitCoroutinesVersion"
	...
	}

	interface RetrofitPosts {

	@GET("posts")
	fun getPosts(): Deferred<Response<List<Post>>>

	}

	abstract class BaseRepository<Params, Result> {

	abstract suspend fun doWork(params: Params): Result

	}

	class PostsRepository :
	BaseRepository<PostsRepository.Params, PostsRepository.Result>() {

	override suspend fun doWork(params: Params): Result {
	val retrofitPosts = Retrofit
	.Builder()
	.baseUrl("https://jsonplaceholder.typicode.com")
	.addConverterFactory(MoshiConverterFactory.create())
	.addCallAdapterFactory(CoroutineCallAdapterFactory())
	.build()
	.create(RetrofitPosts::class.java)
	val result = retrofitPosts
	.getPosts()
	.await()

	return Result(result.body())
	}

	class Params
	data class Result(val posts: List<Post>?)
	}

	abstract class BaseUseCase<Params, Result> {

	abstract suspend fun doWork(params: Params): Result

	}

	class GetListOfPostsUseCase
	: BaseUseCase<GetListOfPostsUseCase.Params, GetListOfPostsUseCase.Result>() {

	override suspend fun doWork(params: Params): Result {
	return Result(
	PostsRepository()
	.doWork(PostsRepository.Params())
	.response
	.posts
	)
	}

	class Params
	class Result(val posts: List<Post>?)
	}

	fun doWork() {
	val useCase = GetListOfPostsUseCase()
	viewModelScope.launch {
	withContext(Dispatchers.IO) {

	val result = useCase.doWork(
	GetListOfPostsUseCase.Params()
	)
	Log.d("coroutines example", "get list of posts = ${result.posts}")
	}
	}

	}

	fun cancelJob() {
	viewModelJob.cancel()
	}

	abstract class BaseViewModel : ViewModel() {

	private var viewModelJob = Job()
	private val viewModelScope = CoroutineScope(Dispatchers.Main + viewModelJob)
	private var isActive = true

	// Do work in IO
	fun <P> doWork(doOnAsyncBlock: suspend CoroutineScope.() -> P) {
	doCoroutineWork(doOnAsyncBlock, viewModelScope, IO)
	}

	// Do work in Main
	// doWorkInMainThread {...}
	fun <P> doWorkInMainThread(doOnAsyncBlock: suspend CoroutineScope.() -> P) {
	doCoroutineWork(doOnAsyncBlock, viewModelScope, Main)
	}

	// Do work in IO repeately
	// doRepeatWork(1000) {...}
	// then we need to stop it calling stopRepeatWork()
	fun <P> doRepeatWork(delay: Long, doOnAsyncBlock: suspend CoroutineScope.() -> P) {
	isActive = true
	viewModelScope.launch {
	while (this@BaseViewModel.isActive) {
	withContext(IO) {
	doOnAsyncBlock.invoke(this)
	}
	if (this@BaseViewModel.isActive) {
	delay(delay)
	}
	}
	}
	}

	fun stopRepeatWork() {
	isActive = false
	}

	override fun onCleared() {
	super.onCleared()
	isActive = false
	viewModelJob.cancel()
	}

	private inline fun <P> doCoroutineWork(
	crossinline doOnAsyncBlock: suspend CoroutineScope.() -> P,
	coroutineScope: CoroutineScope,
	context: CoroutineContext
	) {
	coroutineScope.launch {
	withContext(context) {
	doOnAsyncBlock.invoke(this)
	}
	}
	}
	}

	class PostViewModel : BaseViewModel() {

	val lengthOfPostsList = MutableLiveData<String>()

	fun getListOfPosts() {
	doWork {
	val result = GetListOfPostsUseCase()
	.doWork(GetListOfPostsUseCase.Params())
	Log.d("coroutines example", "get list of posts = ${result.posts}")
	lengthOfPostsList.postValue(result.posts?.size.toString())
	}
	}

Expérience avec Coroutines et Retrofit2

Qu'est ce que c'est

Pourquoi?

Exemple

Faire mieux

Nous connectons retrofit2

Le rendre meilleur

Conclusion

More articles: