Introdução ao Kotlin Flow

Uma apresentação que brindei para a comunidade Kotlin São Paulo onde falamos acerca dos fluxos que podem ser criados com o Kotlin Flow.
Você vai encontrar o video desta palestra em: https://www.youtube.com/watch?v=DzxVVD6WAnE

Transcript

1. Introdução ao Kotlin Flow Armando Picón Senior Android Developer at Cornershop Inc. @devpicon https://linktr.ee/devpicon
2. O que é um Flow? • Para começar os fluxos do Kotlin Flow vão ser utilizados para aquelas situações onde é preciso fazer o retorno dos múltiplos valores processados assincronamente • O Kotlin Flow está baseado em frameworks reativos como RxJava • Cada um dos fluxos vai precisar de alguém para coletar (recolher) pelos resultados, é por isso que a diferença dos Kotlin Channels, estes são frios (cold)
3. Emitter Collector
4. Emitter Collector flow{ emit() } collect()
5. Emitter Collector flow{ emit() } collect() Flow builder
6. Flow builders • flow{} -> o builder mais básico, vai te ajudar a criar um fluxo ou flow desde um bloco do código que pode ser suspenso • flowOf() -> vai estabelecer um fluxo com um conjunto fixo de dados • .asFlow() -> é uma extension function para criar um fluxo desde uma coleção de dados
7. flow{ emit() } collect() Flow builder Emitter Collector
8. flow{ emit() } collect() map{} filter{} transform{} take() Flow builder Emitter Collector
9. flow{ emit() } collect() intermediate operators map{} filter{} transform{} take() Flow builder Emitter Collector
10. Operadores intermediários Intermediate flow operators • map{} -> vai retornar um fluxo com o resultado de aplicar uma função para transformar cada um dos valores do fluxo • filter{} -> vai retornar um fluxo com só os dados que coincidem com uma condição definida • transform{} -> vai permitir fazer transformações simples e complexas. Podemos emitir valores por uma quantidade de vezes • take() -> vai finalizar a execução do fluxo quando o limite seja alcançado
11. flow{ emit() } collect() map{} filter{} transform{} take() Flow builder operadores intermedios Emitter Collector
12. flow{ emit() } collect() Terminal flow operator map{} filter{} transform{} take() Flow builder operadores intermedios Emitter Collector
13. Operadores terminais (Terminal flow operators) • collect{} -> vai coletar o fluxo com uma ação provida • reduce{} -> vai acumular os dados começando com o dado primeiro e aplicando o operador definido. Vai lançar um NoSuchElementException se o fluxo estiver vazio • fold{} -> muito similar ao “reduce”, mas com uma diferença, este vai começar com um dado inicial provido São funções suspensas que vão começar a coleta dos dados do fluxo
14. Operadores terminais (Terminal flow operators) • first{} -> aquele retorna o primeiro elemento emitido pelo fluxo e depois cancela o fluxo. Lança uma "NoSuchElementException" se o fluxo estiver vazio • single{} -> aquele espera por apenas um valor para ser publicado. Lança uma NoSuchElementException para um fluxo vazio e uma IllegalStateException se o fluxo contiver mais de um elemento São funções suspensas que vão começar a coleta dos dados do fluxo
15. Operadores terminais (Terminal flow operators) • toList(), toSet() -> coletam os valores do fluxo e os converte em uma coleção São funções suspensas que vão começar a coleta dos dados do fluxo
16. Operadores terminais (Terminal flow operators) • toList(), toSet() -> coletam os valores do fluxo e os converte em uma coleção • asLiveData() -> coletam os valores do fluxo e os converte em um livedata São funções suspensas que vão começar a coleta dos dados do fluxo androidx.lifecycle:lifecycle-livedata-ktx
17. Preservação do contexto (Context preservation) • As coleções sempre acontecem no contexto da corotina que chamou o fluxo • Você não pode mudar do contexto quando uma coleção está em execução. • Fazendo uso do operador flowOn() é a única maneira possível para mudar o contexto da execução
18. Os fluxos são sequenciais (Flows are sequential) • Se cada coleta de um fluxo é realizada sequencialmente, o que acontece se a coleta e emissão forem lentas?
19. Emitter Collector delay(100) emit delay(100) println(it) delay(100) emit delay(100)
20. A execução sequencial pode ser um problema? (Could be the sequential execution an issue?) • A execução sequencial pode ser um problema potencial quando o emissor e o coletor precisaram de muito tempo para completar suas tarefas • É importante lembrar que os fluxos são executados no contexto da mesma corotina
21. Os desafios para desacoplar o emissor e coletor (Challenges to decouple the emitter and the collector) • Executar o emissor em uma corotina separada pode fazer com que os dois se tornem simultâneos • Com duas corotinas separadas, precisaríamos de alguns meios de comunicação para conectá-los • Os canais (channels) proporcionam um mecanismo onde podemos enviar um elemento de um transmissor e recebê-lo em outro ponto através de um canal
22. Só para lembrar... ...os canais são quentes e faz possível ter um buffer
23. Operador Buffer (Buffer operator) • O uso de um buffer permite tratar esta situação, através de um canal é possível acumular e consumir os elementos à medida que são gerados. • O operador buffer cria uma corotina separada durante a execução do fluxo
24. Emitter Collector delay(100) emit delay(100) println(it) delay(100) emit delay(100) println(it) delay(100) emit
25. Transparência das exceções (Exception transparency) • As exceções podem ser relançadas • Exceções também podem ser lançadas desde o bloco catch{} • As exceções podem ser ignoradas ou processadas por algum outro código
26. Show me some code dude! https://github.com/DevPicon/kotlin-marvel-hero-finder
27. Referencias • Asynchronous Flow https://kotlinlang.org/docs/reference/coroutines/flow.html • Cold flows, hot channels https://medium.com/@elizarov/cold-flows-hot-channels-d74769805f9 • Simple design of Kotlin Flow https://medium.com/@elizarov/simple-design-of-kotlin-flow-4725e7398c4c • Kotlin Flows and Coroutines https://medium.com/@elizarov/kotlin-flows-and-coroutines-256260fb3bdb
28. Leitura recomendada • Asynchronous development in Android: RxJava vs Kotlin Flow https://medium.com/makingtuenti/asynchronous-development-in-android-rxja va-vs-kotlin-flow-f7fdf2e2f81b • From RxJava 2 to Kotlin Flow: Threading https://proandroiddev.com/from-rxjava-2-to-kotlin-flow-threading-8618867e1 955 • The Real Kotlin Flow benefits over RxJava https://proandroiddev.com/the-real-kotlin-flow-benefits-over-rxjava-c19b99ba 6eb9
29. Codalot Podcast anchor.fm/codalot youtube.com/devpicon Obrigado! /devpicon