Kotlin Flow

An early look at Kotlin Flow

Transcript

1. KOTLIN FLOW JOSÉ CAIQUE
2. produce(capacity = 20) { (0..10).forEach { send(it) println("sent $it") } } //emmit : 1,2,3 … val intFlow = flow { for (i in 0 until 10) { emit(i) println("sent flow $i") } } // intFlow.collect{ }
 // 1,2,3… HOT CHANNEL COLD STREAM implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0-M1'
3. @ExperimentalCoroutinesApi public interface Flow<out T> { @InternalCoroutinesApi public suspend fun collect(collector: FlowCollector<T>) } BackPressure by Default
4. BUILDERS ▸ (0..2).asFlow() ▸ flow{ emit(1) } ▸ flowOf(1, 2, 3, 4, 5) ▸ channelFlow { send(1) } ▸ emptyFlow<T>()
5. (0..1).asFlow() .map { println("Thread0 ${Thread.currentThread().name}") it*it } .filter { println("Thread1 ${Thread.currentThread().name}") it % 4 == 0 } .flowOn(Dispatchers.IO) .map { println("Thread2 ${Thread.currentThread().name}") it * 2 } .flowOn(Dispatchers.Default) Thread0 DefaultDispatcher-worker-2 Thread1 DefaultDispatcher-worker-2 Thread0 DefaultDispatcher-worker-2 Thread1 DefaultDispatcher-worker-2 Thread2 main
6. //requestA(Flow) -> 1000L //requestB(Flow) -> 2000L requestA() .zip(requestB()) { requestA, requestB -> requestA + requestB }.collect { println(it) } Total: ~2100L
7. //requestA(suspend) -> 1000L //requestB(suspend) -> 2000L channelFlow<Pair<Int, String>> { val result1 = async { requestA() } val result2 = async { requestB() } val result3 = result1.await() to result2.await() send(result3) }.collect { println(it) } // buffer, still cold stream Total: ~2100L
8. val myFlow = flow { // GlobalScope.launch { // is prohibited // launch(Dispatchers.IO) { // is prohibited // withContext(CoroutineName("myFlow")) // is prohibited emit(1) // OK coroutineScope { emit(2) // OK -- still the same coroutine } }
9. channelFlow { launch(IO){ send(requestA()) } launch(Main) { send(requestB()) } }.collect { println(it) }
10. val broadcast: ConflatedBroadcastChannel<User> // emitting launch { broadcast.send(user) } // listening broadcast.consumeEach { service .retrieve(it) .map { it.getOrNull() } .collect { it?.let { … } } } //close broadcast.close()
11. EXTENSIONS ‣ broadcastIn ‣ buffer ‣ collect ‣ combineLatest ‣ conflate ‣ count ‣ debounce ‣ delayEach ‣ delayFlow ‣ distinctUntilChanged ‣ distinctUntilChangedBy ‣ drop ‣ dropWhile ‣ filter ‣ filterIsInstance ‣ filterNot ‣ filterNotNull ‣ first ‣ flatMapConcat ‣ flatMapMerge ‣ flattenConcat ‣ flattenMerge ‣ flowWith ‣ fold ‣ map ‣ mapNotNull ‣ onEach ‣ onErrorCollect ‣ onErrorReturn ‣ produceIn ‣ reduce ‣ retry ‣ sample ‣ scan ‣ scanFold ‣ scanReduce ‣ single ‣ singleOrNull ‣ switchMap ‣ take ‣ takeWhile ‣ toCollection ‣ toList ‣ toSet ‣ transform ‣ zip
12. fun <T> Flow<T>.startWith(start: T) = flow { collect { value -> emit(start) emit(value) } } flowOf("Caique") .startWith("Jose") .collect { println(it) } 
 // José
 // Caique EASY TO CREATE EXTENSIONS
13. MORE EXTENSIONS ARE COMING https://github.com/Kotlin/kotlinx.coroutines/issues/1263 https://github.com/Kotlin/kotlinx.coroutines/issues/1261 https://github.com/Kotlin/kotlinx.coroutines/issues/1247 https://github.com/Kotlin/kotlinx.coroutines/issues/1186
14. JOSÉ CAIQUE ▸ Software Engineer ▸ Computer Science by UFS ▸ Android Tech Lead at Stone ▸ Speaker
15. 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