🔐 🍖 🙍🏾 Coroutines और Retrofit2 के साथ अनुभव करें 🤚🏾 😩 🦒

यह क्या है

किसने अभी तक प्रलेखन नहीं पढ़ा है - मैं आपको खुद को परिचित करने के लिए अत्यधिक सलाह देता हूं।

जेटब्रेन क्या लिखता है:

लाइब्रेरी के अंदर सभी जटिलताओं को छोड़ते हुए, कोराउटीन अतुल्यकालिक प्रोग्रामिंग को सरल बनाते हैं। कार्यक्रम के तर्क को कोरटाइन्स में क्रमिक रूप से व्यक्त किया जा सकता है, और आधार पुस्तकालय इसे हमारे लिए अतुल्यकालिक रूप से लागू करेगा। पुस्तकालय संबंधित घटनाओं की सदस्यता लेने वाले कॉलबैक में उपयोगकर्ता कोड के संबंधित भागों को लपेट सकता है, और अलग-अलग थ्रेड (या यहां तक कि अलग-अलग मशीनों के लिए निष्पादन को भी प्रेषण) कर सकता है। कोड उतना ही सरल रहेगा जितना कि सख्ती से क्रम से निष्पादित किया जाएगा।

सरल शब्दों में, यह सिंक्रोनस / एसिंक्रोनस कोड निष्पादन के लिए एक पुस्तकालय है।

क्यों?

क्योंकि RxJava अब फैशन में नहीं है (सिर्फ मजाक कर रहा है)।

सबसे पहले, मैं कुछ नया करने की कोशिश करना चाहता था, और दूसरी बात, मैं एक लेख - कोरुटिन की गति और अन्य तरीकों की तुलना में आया था।

उदाहरण

उदाहरण के लिए, आपको पृष्ठभूमि में एक ऑपरेशन करने की आवश्यकता है।

आरंभ करने के लिए - corutin पर हमारे build.gradle निर्भरता में जोड़ें:

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

हम अपने कोड में विधि का उपयोग करते हैं:

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

view raw gistfile1.txt hosted with ❤ by GitHub

जहां संदर्भ में - हम उस थ्रेड पूल को निर्दिष्ट करते हैं जिसकी हमें आवश्यकता है - सरल मामलों में, ये आईओ, मुख्य और डिफ़ॉल्ट हैं

IO - एपीआई के साथ सरल संचालन के लिए, डेटाबेस के साथ संचालन, साझा प्राथमिकताएं आदि।
मुख्य - यूआई धागा, जहां से हम दृश्य तक पहुंच सकते हैं
डिफ़ॉल्ट - उच्च सीपीयू लोड के साथ भारी संचालन के लिए
(इस लेख में और अधिक)

ब्लॉक - लांबा जिसे हम निष्पादित करना चाहते हैं

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

सिद्धांत रूप में, यह सब, हमें 1 से 1000 तक वर्गों के योग का परिणाम मिलता है और साथ ही हम मुख्य धागे को ब्लॉक नहीं करते हैं, जिसका अर्थ है कि कोई ANR नहीं

हालांकि, अगर हमारी कोरटाइन को 20 सेकंड के लिए निष्पादित किया जाता है और इस समय के दौरान हमने डिवाइस के 2 मोड़ बनाए हैं, तो हमारे पास 3 एक साथ चलने वाले ब्लॉक होंगे। उफ़।

और अगर हमने ब्लॉक में गतिविधि के लिए एक लिंक पारित किया - एक रिसाव और पुराने ब्लॉकों में दृश्य के साथ संचालन करने की क्षमता की कमी। दो बार उफ़।

तो क्या करें?

बेहतर कर रहे हैं

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

इस प्रकार, हम स्ट्रीम में अपने कोड के निष्पादन को रोकने में सक्षम थे, उदाहरण के लिए, जब स्क्रीन को घुमाया जाता है।

CoroutineScope ने सभी नेस्टेड कॉरआउट्स के दायरे को संयोजित करना संभव बनाया और, जब job.cancel () को कॉल किया, तो उनके निष्पादन को रोक दिया।

यदि आप निष्पादन को रोकने के बाद गुंजाइश का पुन: उपयोग करने की योजना बनाते हैं, तो आपको job.cancelChildren () के बजाय job.cancel () का उपयोग करने की आवश्यकता है। टिप्पणी के लिए धन्यवाद Neikist

उसी समय, हमारे पास अभी भी प्रवाह को नियंत्रित करने का अवसर है:

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

हम रेट्रोफ़िट 2 कनेक्ट करते हैं

ओलों के लिए निर्भरता जोड़ें:

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

हम एक उदाहरण के रूप में कलम का उपयोग करते हैं https://my-json-server.typicode.com/typicode/demo/posts

हम रेट्रोफिट इंटरफ़ेस का वर्णन करते हैं:

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

view raw RetrofitPosts.kt hosted with ❤ by GitHub

लौटे पोस्ट मॉडल का वर्णन करें:

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

view raw Post.kt hosted with ❤ by GitHub

हमारा बेसरेपोसिटरी:

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

view raw BaseRepository.kt hosted with ❤ by GitHub

PostRepository का कार्यान्वयन:

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

हमारा बेसउसेकेस:

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

view raw BaseUseCase.kt hosted with ❤ by GitHub

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

यहाँ परिणाम है:

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

इसे बेहतर बनाना

मैं एक आलसी प्राणी हूं और हर बार जब मैं कोड की पूरी शीट को बाहर नहीं निकालना चाहता, तो मैंने 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

अब डाक सूची प्राप्त करना इस प्रकार है:

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

निष्कर्ष

मैंने उत्पादों में कोराउटाइन का उपयोग किया और कोड वास्तव में क्लीनर और अधिक पठनीय निकला।

युपीडी:
रेट्रोफ़िट अपवाद हैंडलिंग विवरण टिप्पणी देखें

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

Coroutines और Retrofit2 के साथ अनुभव करें

यह क्या है

क्यों?

उदाहरण

बेहतर कर रहे हैं

हम रेट्रोफ़िट 2 कनेक्ट करते हैं

इसे बेहतर बनाना

निष्कर्ष

More articles: