Aplicações assíncronas no Android com Coroutines & Jetpack

Coroutines & Jetpack
Aplicações assíncronas no Android com
Nelson Glauber
@nglauber 
slideshare.com/nglauber 
youtube.com/nglauber

A main thread do Android
• Carregar arquivo de layout

• Desenhar as views

• Tratar os eventos de UI

• …

Async no Android
• AsyncTask !

• Thread + Handler "

• Loaders (deprecated) !

• Volley #$

• RxJava 🧐

Coroutines
• Essencialmente, coroutines são light-weight threads.

• Fácil de usar (sem mais "callbacks hell” e/ou centenas de
operadores).

• Úteis para operações de I/O ou qualquer outra tarefa
computacional mais onerosa.

• Permite a substituição de callbacks por operações
assíncronas.

Dependências
dependencies {
def coroutines_version = '1.2.1'
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines_version"
...
}

suspend
• Suspending functions são o centro de tudo em Coroutines.
Elas são basicamente funções que podem ser pausadas e
retomadas após algum tempo.

• Podem executar longas tarefas e aguardar o resultado sem
bloquear a thread atual.

• A sintaxe é idêntica a uma função “normal”, exceto pela
adição da palavra reservada suspend.

• Por si só, uma suspending function não é assíncrona.

• Só pode ser chamada a partir de outra suspending function.

import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.Assert.assertEquals
class CalculatorUnitTest {
@Test
fun sum_isCorrect() = runBlocking {
val calc = Calculator()
assertEquals(4, calc.sum(2, 2))
}
}
import kotlinx.coroutines.delay
class Calculator {
suspend fun sum(a: Int, b: Int): Int {
delay(5_000)
return a + b
}
}

Coroutines no Android
• Para entendermos melhor as Coroutines no Android
precisamos falar de 4 conceitos:

• Job

• Context

• Scope

• Dispatcher

class MainActivity : AppCompatActivity() {
private val job = Job()
private val coroutineScope = CoroutineScope(job + Dispatchers.Main)
override fun onDestroy() {
super.onDestroy()
job.cancel()
}
fun callWebService() {
coroutineScope.launch {
txtOutput.text = ""
val books = withContext(Dispatchers.IO) {
BookHttp.loadBooks()
}
books?.forEach {
txtOutput.append("${it.title}n")
}
}
}
...

super.onDestroy()
job.cancel()
}
txtOutput.text = ""
}
books?.forEach {
}
}
}
...
Job
• Um Job representa uma tarefa ou conjunto de
tarefas em background.

• A função launch retorna um Job.

• Mantém a referência do código que está em
execução.

• Pode possuir “ﬁlhos”.

• Pode ser cancelado usando a função cancel.

super.onDestroy()
job.cancel()
}
txtOutput.text = ""
}
books?.forEach {
}
}
}
...
Context
• É um conjunto de atributos que conﬁguram
uma coroutine.

• Representada pela interface
CoroutineContext.

• Pode deﬁnir a política de threading,
tratamento de exceções, etc.

super.onDestroy()
job.cancel()
}
txtOutput.text = ""
}
books?.forEach {
}
}
}
...
Scope
• Um escopo serve como uma espécie de ciclo de
vida para um conjunto de coroutines.

• Coroutines sempre rodam em um escopo.

• Permite um maior controle das tarefas em
execução

GlobalScope
• O GlobalScope, como o nome sugere, é utilizado em tarefas cujo o escopo é
global da aplicação.

• O GlobalScope é considerado um anti-pattern no Android e deve ser evitado.
private suspend fun loadName(): String {
delay(5000)
return "Glauber"
}
private fun firstCoroutine() {
GlobalScope.launch {
val name = loadName()
println("$name!")
}
println("Hello, ")
}

super.onDestroy()
job.cancel()
}
txtOutput.text = ""
}
books?.forEach {
}
}
}
...
Dispatcher
• Um dispatcher deﬁne o pool de threads
que a coroutine executará.

• Default - É otimizado para processos
que usam a CPU mais intensamente.

• IO - recomendado para tarefas de rede
ou arquivos. O pool de threads é
compartilhado com o dispatcher
DEFAULT.

• Main - main thread do Android.

txtOutput.text = ""
}
books?.forEach {
addTextToTextView("${it.title}n")
}
}
}
&

txtOutput.text = ""
val books = BookHttp.loadBooks()
books?.forEach {
}
}
}
android.os.NetworkOnMainThreadException
at android.os.StrictMode$AndroidBlockGuardPolicy.onNetwork(StrictMode.java:1513)
at java.net.Inet6AddressImpl.lookupHostByName(Inet6AddressImpl.java:117)
at java.net.Inet6AddressImpl.lookupAllHostAddr(Inet6AddressImpl.java:105)
at java.net.InetAddress.getAllByName(InetAddress.java:1154)
at com.android.okhttp.Dns$1.lookup(Dns.java:39)

FATAL EXCEPTION: DefaultDispatcher-worker-1
Process: br.com.nglauber.coroutinesdemo, PID: 26507
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that
created a view hierarchy can touch its views.
at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:7753)
at android.view.ViewRootImpl.requestLayout(ViewRootImpl.java:1225)
coroutineScope.launch(Dispatchers.IO){
txtOutput.text = ""
val books = BookHttp.loadBooks()
books?.forEach {
}
}
}

class MainActivity : AppCompatActivity(), CoroutineScope {
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main + job
super.onDestroy()
job.cancel()
}
launch {
txtOutput.text = ""
}
books?.forEach {
}
}
}
...

Lifecycle Scope
• Escopo atrelado ao ciclo de vida da Activity, Fragment ou
View do Fragment

• Além da função launch, podemos usar o
launchWhenCreated, launchWhenStarted e
launchWhenResumed.
dependencies {
...
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha01"
}

class MyActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
...
lifecycleScope.launch {
...
}
// or...
lifecycleScope.launchWhenCreated {
...
}
// or...
lifecycleScope.launchWhenStarted {
...
}
}

class MyFragment : Fragment() {
...
...
}
// or...
lifecycleScope.launchWhenCreated {
...
}
// or...
lifecycleScope.launchWhenStarted {
...
}
}

class MyFragment: Fragment() {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
viewLifecycleOwner.lifecycleScope.launch {
...
}
}
}

ViewModel Scope
 
 
Um ViewModel agora possui a propriedade viewModelScope.
dependencies {
implementation "androidx.lifecycle:lifecycle-extensions:2.2.0-alpha01"
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-alpha01"
testImplementation "androidx.arch.core:core-testing:2.1.0-beta01"
}

class MainViewModel : ViewModel() {
private val _message = MutableLiveData<String>()
val message: LiveData<String> = _message
fun loadMessage() {
viewModelScope.launch {
val message = withContext(Dispatchers.IO) {
loadMessageFromNetwork()
}
_message.value = message
}
}
private suspend fun loadMessageFromNetwork() : String {
delay(2_000)
return "Hello from ViewModel"
}
}

private val viewModel: MainViewModel by lazy {
ViewModelProviders.of(this).get(MainViewModel::class.java)
}
setContentView(R.layout.activity_main)
...
viewModel.message.observe(this, Observer { s ->
txtOutput.text = s
})
viewModel.loadMessage()
}
...

WorkManager
dependencies {
def work_version = "2.1.0-beta02"
implementation "androidx.work:work-runtime-ktx:$work_version"
androidTestImplementation "androidx.work:work-testing:$work_version"
}

class MyWork(context: Context, params: WorkerParameters) :
CoroutineWorker(context, params) {
override suspend fun doWork(): Result = try {
val output = inputData.run {
val x = getInt("x", 0)
val y = getInt("y", 0)
val result = Calculator().sum(x, y)
workDataOf("result" to result)
}
Result.success(output)
} catch (error: Throwable) {
Result.failure()
}
}
private fun callMyWork() {
val request =
OneTimeWorkRequestBuilder<MyWork>()
.setInputData(workDataOf("x" to 84, "y" to 12))
.build()
WorkManager.getInstance(this).run {
enqueue(request)
getWorkInfoByIdLiveData(request.id)
.observe(this@MainActivity, Observer {
if (it.state == WorkInfo.State.SUCCEEDED) {
val result = it.outputData.getInt("result", 0)
addTextToTextView("Result-> $result")
}
})
}

Iniciando uma coroutine
• As duas formas de iniciar uma coroutine são:

• A função launch é uma “ﬁre and forget” que signiﬁca
que não retornará o resultado para que a chamou (mas
retornará um Job).

• A função async retorna um objeto Deferred que permite
obter o seu resultado.

launch = Sequencial
private fun sequentialCalls() {
txtOutput.text = ""
launch {
val time = measureTimeMillis {
val one = doSomethingUsefulOne()
val two = doSomethingUsefulTwo()
addTextToTextView("The answer is ${one + two}")
}
addTextToTextView("Completed in $time ms")
}
}
The answer is 42 
Completed in 2030 ms

async = Paralelo
private fun parallelCalls() {
txtOutput.text = ""
launch {
val time = measureTimeMillis {
val one = async { doSomethingUsefulOne() }
val two = async { doSomethingUsefulTwo() }
addTextToTextView("The answer is ${one.await() + two.await()} ")
}
addTextToTextView("Completed in $time ms")
}
}
The answer is 42 
Completed in 1038 ms

Launch x Async
Em quase todos os casos, deve-se usar a função
launch para iniciar uma coroutine a partir de uma
função “normal”.

Uma função comum não pode chamar o await
(porque ela é uma suspending function), então
não faz muito sentido usar o async como ponto
de partida.

Exceptions
• As exceções tem comportamentos diferentes para o
launch e o async.

Exceptions - launch
private fun handlingException() {
launch {
txtOutput.text = ""
try {
val a = methodThatThrowsException()
addTextToTextView("Ok ${a}")
} catch (e: Exception) {
addTextToTextView("handlingException caught: ${e.message}")
}
}
}

Exceptions - async
private fun handlingAsyncException() {
launch {
txtOutput.text = ""
try {
val task = async { throwingException() }
addTextToTextView("Ok ${task.await()}")
addTextToTextView("handlingAsyncException caught: ${e}")
}
}
}

Exceptions - async #1
private fun handlingAsyncException1() {
launch {
txtOutput.text = ""
val task = async(SupervisorJob(job)) {
methodThatThrowsException()
}
try {
} catch (e: Throwable) {
addTextToTextView("Erro! ${e.message}")
}
}
}

launch {
txtOutput.text = ""
supervisorScope {
val task = async { methodThatThrowsException() }
try {
}
}
}
}

launch {
txtOutput.text = ""
try {
coroutineScope {
val task = async {
methodThatThrowsException()
}
}
}
}
}

Cancelamento
• Para cancelar um job, basta chamar o método cancel.

• Uma vez cancelado o job não pode ser reusado.

• Para cancelar os jobs ﬁlhos, use cancelChildren.

• A propriedade isActive indica que o job está em
execução, isCancelled cancelado, e isCompleted
terminou sua execução.

• Se cancelado enquanto suspenso, levanta
CancellationException.

private fun cancelDemo() {
val startTime = System.currentTimeMillis()
longJob = launch(Dispatchers.Default) {
var nextPrintTime = startTime
var i = 0
while (i < 20 && isActive) { // this == CoroutineScope, que possui isActive
if (System.currentTimeMillis() >= nextPrintTime) {
Log.d("NGVL","job: I'm sleeping ${i++} ...")
nextPrintTime += 500L
}
}
}
}

private fun nonCancellableJob() {
nonCancellableJob = launch {
withContext(NonCancellable) {
println("job: I'm here")
delay(5000L)
println("job: I'm non-cancellable")
}
}
}

withTimeout
• Executa uma coroutine levantando uma
TimeoutCancellationException caso sua duração
exceda o timeout especiﬁcado.

• Uma vez que o cancelamento é apenas uma exceção, é
possível trata-la facilmente.

• É possível usar a função withTimeoutOrNull que é similar
a withTimeout, mas retorna null ao invés de levantar a
exceção.

withTimeout
private fun timeoutDemo() {
launch {
txtOutput.text = ""
try {
withTimeout(1300L) {
repeat(10) { i ->
withContext(Dispatchers.Default) {
delay(500L)
}
addTextToTextView("I'm sleeping $i ...")
}
}
} catch (e: TimeoutCancellationException) { // opcional
addTextToTextView("Exception! ${e.message}")
}
}
}

withTimeoutOrNull
private fun timeoutOrNullDemo() {
launch {
txtOutput.text = ""
val task = async(Dispatchers.Default) {
delay(5000)
"Done!"
}
// suspend until task is finished or return null in 2 sec
val result = withTimeoutOrNull(2000) { task.await() }
addTextToTextView("Result: $result") // ui thread
}
}

Converting Callbacks to
Coroutines
class LocationManager {
fun getCurrentLocation(callback: (LatLng?) -> Unit) {
// get the location...
callback(LatLng(-8.187,-36.156))
}
}
suspend fun getMyLocation(lm: LocationManager): LatLng {
return suspendCoroutine { continuation ->
lm.getCurrentLocation { latLng ->
if (latLng == null) {
continuation.resumeWithException(
Exception("Fail to get user location")
)
} else {
continuation.resume(latLng)
}
}
}
}

Converting Callbacks to
Coroutines
class LocationManager {
fun getCurrentLocation(callback: (LatLng?) -> Unit) {
// get the location...
callback(LatLng(-8.187,-36.156))
}
}
suspend fun getMyLocation(lm: LocationManager): LatLng {
return suspendCancellableCoroutine { continuation ->
lm.getCurrentLocation { latLng ->
if (latLng == null) {
continuation.resumeWithException(
Exception("Fail to get user location")
)
} else {
continuation.resume(latLng)
}
}
}
}

Nos bastidores, uma suspending function é
convertida pelo compilador para uma função (de
mesmo nome) que recebe um objeto do tipo
Continuation. 
 
fun sum(a: Int, b: Int, Continuation<Int>)
Continuation é uma interface que contém duas funções que
são invocadas para continuar com a execução da coroutine
(normalmente retornando um valor) ou levantar uma exceção
caso algum erro ocorra. 
interface Continuation<in T> {
val context: CoroutineContext
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}

Channel
• Serve basicamente para enviar dados de
uma coroutine para outra.

• O conceito de canal é similar a uma
blocking queue mas utiliza suspending
operations ao invés de blocking operations.
EXPERIMENTAL

2019-06-11 21:08:41.988 5545-5545/br.com.nglauber.coroutinesdemo I/System.out: 1
2019-06-11 21:08:42.051 5545-5545/br.com.nglauber.coroutinesdemo I/System.out: Done!
val channel = Channel<Int>()
launch {
// this might be heavy CPU-consuming computation or
// async logic, we’ll just send five squares
for (x in 1..5) channel.send(x * x)
}
// here we print five received integers:
repeat(5) { println(channel.receive()) }
println("Done!")
}

import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.channels.ReceiveChannel
class NumberSender {
private var currentValue = 0
private val numberChannel = BroadcastChannel<Int>(10)
fun getChannel(): ReceiveChannel<Int> =
numberChannel.openSubscription()
suspend fun sendNext() {
numberChannel.send(currentValue++)
}
fun close() = numberChannel.close()
}

class ChannelActivity : AppCompatActivity() {
private val sender = NumberSender()
setContentView(R.layout.activity_channel)
btnProduce.setOnClickListener {
sender.sendNext()
}
}
sender.getChannel().consumeEach {
txtOutput.append("Number: $it n")
}
}
}
super.onDestroy()
sender.close()
}
}

Actors
• Basicamente, um ator é um elemento que
recebe mensagens por meio de um canal e
realiza algum trabalho baseado nelas.

• O retorno dessa função é um objeto do tipo
SendChannel que pode ser usado para
enviar mensagens para essa coroutine.
EXPERIMENTAL

class BooksWithActorViewModel : ViewModel() {
private var _screenState = MutableLiveData<State>()
val screenState: LiveData<State> = _screenState
private val actor: SendChannel<Action> = viewModelScope.actor {
for (action in this) when (action) {
is Action.LoadBooks -> doLoadBooks()
}
}
private suspend fun doLoadBooks() {
try {
_screenState.value = State.LoadingResults(true)
}
_screenState.value = State.BooksResult(books)
_screenState.value = State.ErrorResult(Exception(e))
} finally {
_screenState.value = State.LoadingResults(false)
}
}
fun loadBooksFromWeb() {
actor.offer(Action.LoadBooks)
}
override fun onCleared() {
super.onCleared()
actor.close()
}
}

class ActorDemoActivity : AppCompatActivity() {
private val viewModel: BooksWithActorViewModel by lazy { ... }
setContentView(R.layout.activity_actor_demo)
viewModel.screenState.observe(this, Observer { state ->
when (state) {
is State.LoadingResults -> showLoading(state.isLoading)
is State.BooksResult -> showResults(state.books)
is State.ErrorResult -> showError(state.t)
}
})
btnLoad.setOnClickListener {
viewModel.loadBooksFromWeb()
}
}
private fun showResults(books: List<Book>) {
txtResult.text = ""
books.forEach { txtResult.append("${it.title}n") }
}
private fun showLoading(show: Boolean) {
pbLoading.visibility = if (show) View.VISIBLE else View.GONE
}
private fun showError(t: Throwable) {
Toast.makeText(this, "${t.message}", Toast.LENGTH_SHORT).show()
}
}

Flow
• Flow é uma abstração de um cold stream.

• Nada é executado/emitido qualquer item até que algum
consumidor se registre no ﬂuxo.

• Diversos operadores como no RxJava.
EXPERIMENTAL

@FlowPreview
public interface Flow<out T> {
public suspend fun collect(collector: FlowCollector<T>)
}
@FlowPreview
public interface FlowCollector<in T> {
public suspend fun emit(value: T)
}

private fun flowDemo() {
val intFlow = flow {
for (i in 0 until 10) {
emit(i) //calls emit directly from the body of a FlowCollector
}
}
launch {
txtOutput.text = ""
intFlow.collect { number ->
addTextToTextView("$numbern")
}
addTextToTextView("DONE!")
}
}

private fun flowDemo2() {
launch {
txtOutput.text = ""
(0..100).asFlow()
.map { it * it } // executed in IO
.filter { it % 4 == 0 } //executed in IO
.flowOn(Dispatchers.IO) //changes upstream context, asFlow, map and filter
.map { it * 2 } // not affected, continues in parent context
.flowOn(Dispatchers.Main)
.collect {number ->
addTextToTextView("$numbern")
}
}
}

import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.asFlow
class NumberFlow {
private var currentValue = 0
private val numberChannel = BroadcastChannel<Int>(10)
fun getFlow(): Flow<Int> = numberChannel.asFlow()
suspend fun sendNext() {
numberChannel.send(currentValue++)
}
fun close() = numberChannel.close()
}

class FlowActivity : AppCompatActivity() {
private val sender = NumberFlow()
setContentView(R.layout.activity_flow)
btnProduce.setOnClickListener {
sender.sendNext()
}
}
sender.getFlow()
.collect {
txtOutput.append("Number: $it n")
}
}
}
super.onDestroy()
sender.close()
}
}

Room
dependencies {
def room_version = "2.1.0-rc01"
implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"
// 👇 Kotlin Extensions and Coroutines support for Room
implementation "androidx.room:room-ktx:$room_version"
...
}

@Dao
interface UserDao {
@Query("SELECT * FROM user")
suspend fun getAll(): List<User>
@Query("SELECT * FROM user WHERE uid = :id")
suspend fun getUser(id: Long): User
@Insert
suspend fun insert(users: User): Long
@Delete
suspend fun delete(user: User)
}

@Dao
interface UserDao {
suspend fun getAll(): ReceiveChannel<List<User>>
suspend fun getUser(id: Long): ReceiveChannel<User>
@Insert
@Delete
}
NOT 
IMPLEMENTED. 
YET?

@Dao
interface UserDao {
suspend fun getAll(): Flow<List<User>>
suspend fun getUser(id: Long): Flow<User>
@Insert
@Delete
}
NOT 
IMPLEMENTED. 
YET?

LiveData
dependencies {
implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha01"
}
val users: LiveData<List<User>> = liveData {
val data = dao.getAll()
emit(data)
}
...
users.observe(this) { users ->
users.forEach { Log.d("NGVL", it.toString()) }
}

LiveData
@Dao
interface UserDao {
...
fun getLiveAll(): LiveData<List<User>>
}
val users: LiveData<List<User>> = liveData {
val data = dao.getLiveAll()
emitSource(data)
}
... 
users.observe(this) { users ->
users.forEach { Log.d("NGVL", it.toString()) }
}

Conclusão
• Coroutines vêm se tornando a forma de padrão para
realizar código assíncrono no Android.

• Essa é uma recomendação do Google.

• Além do Jetpack, outras bibliotecas estão migrando pro
Jetpack (ex: Retroﬁt).

• Muita atenção para as APIs experimentais de hoje. Elas
podem ser o seu código de amanhã!

Referências #1
• Android Suspenders (Android Dev Summit 2018) 
https://www.youtube.com/watch?v=EOjq4OIWKqM

• Understand Kotlin Coroutines on Android (Google I/O 2019) 
https://www.youtube.com/watch?v=BOHK_w09pVA

• Coroutines Guide 
https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-
guide.md

• Android Suspenders by Chris Banes (KotlinConf 2018) 
https://www.youtube.com/watch?v=P7ov_r1JZ1g

• Room & Coroutines (Florina Muntenescu) 
https://medium.com/androiddevelopers/room-coroutines-422b786dc4c5

Referências #2
• Using Kotlin Coroutines in your Android App 
https://codelabs.developers.google.com/codelabs/kotlin-coroutines

• Use Kotlin coroutines with Architecture Components 
https://developer.android.com/topic/libraries/architecture/coroutines

• Create a Clean-Code App with Kotlin Coroutines and Android Architecture
Components 
https://blog.elpassion.com/create-a-clean-code-app-with-kotlin-coroutines-
and-android-architecture-components-f533b04b5431

• Android Coroutine Recipes (Dmytro Danylyk) 
https://proandroiddev.com/android-coroutine-recipes-33467a4302e9

• Kotlin Coroutines patterns & anti-patterns 
https://proandroiddev.com/kotlin-coroutines-patterns-anti-patterns-
f9d12984c68e

Referências #3
• The reason to avoid GlobalScope (Roman Elizarov) 
https://medium.com/@elizarov/the-reason-to-avoid-globalscope-835337445abc
• WorkManager meets Kotlin (Pietro Maggi) 
https://medium.com/androiddevelopers/workmanager-meets-kotlin-
b9ad02f7405e

• Coroutine Context and Scope (Roman Elizarov) 
https://medium.com/@elizarov/coroutine-context-and-scope-c8b255d59055

• Easy Coroutines in Android: viewModelScope (Manuel Vivo) 
https://medium.com/androiddevelopers/easy-coroutines-in-android-
viewmodelscope-25bﬀb605471

• Exceed the Android Speed Limit 
https://medium.com/androiddevelopers/exceed-the-android-speed-limit-
b73a0692abc1

Referências #4
• An Early look at Kotlin Coroutine’s Flow 
https://proandroiddev.com/an-early-look-at-kotlin-coroutines-
ﬂow-62e46baa6eb0

• Coroutines on Android (Sean McQuillan) 
https://medium.com/androiddevelopers/coroutines-on-android-part-i-getting-
the-background-3e0e54d20bb
• Kotlin Flows and Coroutines (Roman Elizarov) 
https://medium.com/@elizarov/kotlin-flows-and-coroutines-256260fb3bdb
• Simple design of Kotlin Flow (Roman Elizarov) 
https://medium.com/@elizarov/simple-design-of-kotlin-flow-4725e7398c4c
• React Streams and Kotlin Flows (Roman Elizarov) 
https://medium.com/@elizarov/reactive-streams-and-kotlin-flows-
bfd12772cda4

Obrigado!
@nglauber
www.nglauber.com.br

youtube.com/nglauber
slideshare.com/nglauber

Aplicações assíncronas no Android com Coroutines & Jetpack

Recommended

More Related Content

What's hot (20)

Similar to Aplicações assíncronas no Android com Coroutines & Jetpack (20)

More from Nelson Glauber Leal (20)

Recently uploaded (20)

Aplicações assíncronas no Android com Coroutines & Jetpack