COROUTINES AND FLOW JOSÉ CAIQUE

PROGRAM PROCESS THREADS

A PROGRAM IS A SET OF OPERATIONS TO A COMPUTER TO PERFORM. A COMPUTER PROGRAM BECOMES A PROCESS WHEN IT IS LOADED AND BEGINS EXECUTION

A THREAD IS A SEQUENCE OF SUCH INSTRUCTIONS WITH A PROGRAM THAT CAN BE EXECUTED INDEPENDENTLY OF OTHER CODE

COROUTINES

ESSENTIALLY, COROUTINES ARE LIGHT- WEIGHT THREADS

fun main() = runBlocking { val jobs = List(100_000) { launch { delay(1000L) print(".") } } jobs.forEach { it.join() } } java.lang.OutOfMemoryError fun main() { val jobs = List(100_000) { thread { sleep(1000L) print(".") } } jobs.forEach { it.join() } } COROUTINES THREADS

DISPATCHERS

WHICH THREAD WILL LAUNCH THE COROUTINE

- DISPATCHERS.MAIN (ANDROID ONLY) - DISPATCHERS.DEFAULT - DISPATCHERS.IO - DISPATCHERS.UNCONFINED

fun main() { GlobalScope.launch(Main) {} GlobalScope.launch(IO) {} GlobalScope.launch(Main) {} GlobalScope.launch(Unconfined) {} GlobalScope.launch(newSingleThreadContext("myContext")) {} }

SCOPES

DEFINE A SCOPE FOR NEW COROUTINES. USED TO PROPAGATE THE ELEMENTS AND CANCELLATION

class MyActivity : Activity(), CoroutineScope by MainScope() { override fun onDestroy() { cancel() } } class MyViewModel : ViewModel(), CoroutineScope { override val coroutineContext: CoroutineContext = Main override fun onCleared() { super.onCleared() cancel() } } class MyViewModel : ViewModel() { init { viewModelScope.launch { ... } } }

SUSPEND FUNCTION

EXECUTION OF THE CODE WITHOUT BLOCKING THE CURRENT THREAD OF EXECUTION. A SUSPENDING FUNCTION CANNOT BE INVOKED FROM A REGULAR CODE, BUT ONLY FROM OTHER SUSPENDING FUNCTIONS AND FROM SUSPENDING LAMBDAS

SUSPENDING FUNCTIONS DO NOT BLOCK THE CALLER THREAD. SUSPENDING FUNCTIONS HAVE THE ABILITY TO BLOCK THE EXECUTION OF THE COROUTINE

suspend fun doRequest() : Int { return 1 } suspend fun doRequest(): Int = withContext(IO) { 1 } //withTimeout(1000L){ ... }


suspend fun listFromApi(){ viewState.value = ScreenState.Loading viewState.value = ScreenState.Result(performRequest()) } suspend fun doRequest(): Int = withContext(IO) { 1 }

fun retrieve() : Int { doRequest() } suspend fun doRequest(): Int = withContext(IO) { 1 //some result here } Suspend function 'performRequest' should be called only from a coroutine or another suspend function

BUILDERS

THE WAYS TO RUN A NEW COROUTINE

runBlocking{ viewState.value = ScreenState.Loading viewState.value = performRequest() } @Test fun testSuspendingFunction() = runBlocking { val res = suspendingTask1() assertEquals(0, res) }

val job : Job = viewModelScope.launch{ viewState.value = ScreenState.Loading viewState.value = performRequest() } //job.cancel()

val result : Deferred = viewModelScope.async { viewState.value = ScreenState.Loading viewState.value = performRequest() } result.await() //blocking
 result.cancel()

viewModelScope.launch(Main) { val user = withContext(IO) { userService.doLogin(username, password) } val currentFriends = withContext(IO) { userService.requestCurrentFriends(user) } val suggestedFriends = withContext(IO) { userService.requestSuggestedFriends(user) } val finalUser = user.copy( friends = currentFriends + suggestedFriends) }

viewModelScope.launch(Main) { val user = withContext(IO) { userService.doLogin(username, password) } val currentFriends = async(IO) { userService.requestCurrentFriends(user) } val suggestedFriends = async(IO) { userService.requestSuggestedFriends(user) } val finalUser = user.copy( friends = currentFriends + suggestedFriends) }

REMOVING CALLBACKS

suspend fun login(name: String, psw: String): User = suspendCancellableCoroutine { continuation -> service.doLogin(username, password) { user -> continuation.resume(user) } } //continuation.resumeWithException(error)

FLOW

KOTLIN REACTIVE PROGRAMMING COLD STREAMS + COROUTINES + OPERATORS SIMILAR TO SEQUENCES, FLOWS CAN BE TRANSFORMED USING VARIOUS COMMON OPERATORS LIKE MAP, FILTER, ETC UNLIKE A SEQUENCE, A FLOW IS ASYNCHRONOUS AND ALLOWS SUSPENDING FUNCTIONS ANYWHERE IN ITS BUILDER AND OPERATORS

fun foo(p: Params): Flow = flow { while (hasMore) emit(nextValue) } val ints: Flow = flow { for (i in 1..10) { delay(100) emit(i) } } ints.collect { println(it) }

fun Flow.delayASecond() = flow { collect { value -> // collect from the original flow delay(1000) // delay 1 second emit(value) // emit value to the resulting flow } }

YOU CAN EASILY CREATE YOUR OWN OPERATOR

val broadcast: ConflatedBroadcastChannel // emitting launch { broadcast.send(mMap.getBounds()) } // listening broadcast.consumeEach { service .retrieve(it) .map { it.getOrNull() } .collect { it?.let { … } } } //close broadcast.close()

JOSÉ CAIQUE ▸ Software Engineer ▸ Computer Science by UFS ▸ Android Tech Lead at Stone ▸ Speaker

J C A I Q U E _ J O S E C A I Q U E J O S E C A I Q U E T H A N K S

REFERENCES ▸ http://www.inf.puc-rio.br/~roberto/docs/MCC15-04.pdf ▸ https://searchsoftwarequality.techtarget.com/definition/program ▸ https://stackoverflow.com/questions/43021816/difference-between-thread- and-coroutine-in-kotlin ▸ https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md ▸ https://kotlinlang.org/docs/reference/coroutines/basics.html ▸ https://medium.com/@elizarov/coroutine-context-and-scope-c8b255d59055 ▸ https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/ kotlinx.coroutines/-coroutine-scope/ ▸ https://skillsmatter.com/skillscasts/12727-coroutines-by- example#showModal?modal-signup-complete ▸ https://antonioleiva.com/coroutines/ ▸ https://sourcediving.com/kotlin-coroutines-in-android-e2d5bb02c275 ▸ https://medium.com/@elizarov/simple-design-of-kotlin-flow-4725e7398c4c