Flowing in the Deep - Exploring event streams in Kotlin

Transcript

1. Flowing in the Deep Exploring Event Streams in Kotlin
3. Hannes Dorfmann sockeqwe Gabriel Ittner gabrielittner
5. W FL
6. Flowing in the Deep • Introduction • Operators • Threading • Useful APIs
7. fun doHttpRequest() : X { // A long running operation ... return X }
8. class MyActivity : Activity() { override fun onCreate(b: Bundle) { doHttpRequest() } }
10. class MyActivity : Activity() { override fun onCreate(b: Bundle) { doHttpRequest() } }
11. class MyActivity : Activity() { override fun onCreate(b: Bundle) { thread { doHttpRequest() } } }
12. class MyActivity : Activity() { override fun onCreate(b: Bundle) { thread { val x = doHttpRequest() ??? } } }
13. fun doHttpRequest() : X { // A long running operation ... return X }
14. fun doHttpRequest( callback: (X) -> Unit ){ // A long running operation ... callback(X) }
15. fun doHttpRequest( callback: (X) -> Unit ){ thread { // A long running operation ... callback(X) } }
16. class MyActivity : Activity() { override fun onCreate(b: Bundle) { doHttpRequest { result -> // do something with the result } } }
17. doHttpRequest { ... }
18. doHttpRequest { doHttpRequest { ... } }
19. doHttpRequest { doHttpRequest { doHttpRequest { ... } } }
20. doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { ... } } } }
21. doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { ... } } } } }
22. doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { ... } } } } } }
23. doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { doHttpRequest { ... } } } } } } }
26. Callback Hell
27. fun doHttpRequest( callback: (X) -> Unit ) { // A long running operation ... callback(X) }
28. suspend fun doHttpRequest(): X { // A long running operation ... return X }
29. launch { val a = doHttpRequest() val b = doHttpRequest() val c = doHttpRequest() val d = doHttpRequest() val e = doHttpRequest() val f = doHttpRequest() val g = doHttpRequest() }
30. suspend fun doHttpRequest(): X { // A long running operation ... return X }
31. fun doHttpRequest(continuation : Continuation) { // A long running operation ... }
32. fun doHttpRequest(continuation : Continuation) { // A long running operation ... contination.resume(X) }
33. fun doHttpRequest( callback: (X) -> Unit ){ // A long running operation ... callback(X) }
34. fun doHttpRequest( observer: (X) -> Unit ){ // A long running operation ... observer(X) }
35. Observer Pattern
36. fun doHttpRequest( observer: (X) -> Unit ){ // A long running operation ... observer(X) }
37. fun downloadVideo( observer: (progress) -> Unit ) { }
38. fun downloadVideo( observer: (progress) -> Unit ) { // A long running operation ... observer(0.1) ... observer(0.2) ... observer(1.0) }
39. suspend fun downloadVideo() : ??? { // A long running operation ... ??? } With Coroutines?
40. fun downloadVideo( observer: (progress) -> Unit )
41. interface Downloader { fun downloadVideo( observer: (progress) -> Unit ) }
42. interface Downloader { fun download( observer: (progress) -> Unit ) }
43. interface Downloader<T> { fun download( observer: (T) -> Unit ) }
44. interface Downloader<T> { fun download( observer: (T) -> Unit ) } interface DownloadObserver<T>
45. interface Downloader<T> { fun download( observer: (T) -> Unit ) } interface DownloadObserver<T> { fun emit( value: T ) }
46. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) }
47. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) } interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) }
48. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) } interface Downloader<T> { fun collect( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) }
49. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) } interface Downloader<T> { fun collect( c: Collector<T> ) } interface Collector<T> { fun emit( value: T ) }
50. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) } interface Flow<T> { fun collect( c: Collector<T> ) } interface Collector<T> { fun emit( value: T ) }
51. interface Downloader<T> { fun download( o: DownloadObserver<T> ) } interface DownloadObserver<T> { fun emit( value: T ) } interface Flow<T> { fun collect( c: FlowCollector<T> ) } interface FlowCollector<T> { fun emit( value: T ) }
52. interface Flow<T> { fun collect( c: FlowCollector<T> ) } interface FlowCollector<T> { fun emit( value: T ) } Flow
53. interface Flow<out T> { suspend fun collect( c: FlowCollector<T> ) } interface FlowCollector<in T> { suspend fun emit( value: T ) } Flow
54. fun downloadVideo(): ??? { ... ??? }
55. fun downloadVideo(): Flow<Double> { ... ??? }
56. fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> fun downloadVideo(): Flow<Double> { ... ??? }
57. fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> fun downloadVideo(): Flow<Double> = flow { ... ??? }
58. fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> fun downloadVideo(): Flow<Double> = flow { // this: FlowCollector<Double> ... ??? }
59. fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> fun downloadVideo(): Flow<Double> = flow { // this: FlowCollector<Double> ... emit(0.1) }
60. fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> fun downloadVideo(): Flow<Double> = flow { // this is FlowCollector<Double> ... emit(0.1) ... emit(0.2) ... emit(1.0) }
61. Let it Flow!
62. flow { for (i in 0..5) { delay(100) emit(i) } }
63. class MyViewModel : ViewModel() { init { viewModelScope.launch { flow { for (i in 0..5) { delay(100) emit(i) } } } } }
64. class MyViewModel : ViewModel() { init { viewModelScope.launch { flow { for (i in 0..5) { delay(100) emit(i) } } } } } Launch new coroutine
65. class MyViewModel : ViewModel() { init { viewModelScope.launch { flow { for (i in 0..5) { delay(100) emit(i) } } } } } Launch new coroutine 2.1.0-beta01
66. class MyViewModel : ViewModel() { init { viewModelScope.launch { flow { for (i in 0..5) { delay(100) emit(i) } } } } } Suspending block 
 
 executed in coroutine
67. launch { flow { for (i in 0..5) { delay(100) emit(i) } } }
68. launch { flow { for (i in 0..5) { delay(100) emit(i) } }.collect { value -> println(value) } }
69. launch { flow { for (i in 0..5) { delay(100) emit(i) } }.collect { value -> println(value) } } Observes fl ow
70. launch { flow { for (i in 0..5) { delay(100) emit(i) } }.collect { value -> println(value) } } notify observer about value
71. launch { flow { for (i in 0..5) { delay(100) emit(i) } }.collect { value -> println(value) } }
72. What about errors?
73. flow<Double> { throw Exception("Something went wrong") }.collect { println(it) }
74. flow<Double> { throw Exception("Something went wrong") }.collect { println(it) } re-throws
75. try { flow<Double> { throw Exception("Something went wrong") }.collect { println(it) } } catch (e: Exception) { // handle error }
76. flow<Double> { emit(0.1) throw Exception("Something went wrong") }.collect { println(it) }
77. flow<Double> { emit(0.1) throw Exception("Something went wrong") }.collect { println(it) } sealed class DownloadStatus { }
78. flow<Double> { emit(0.1) throw Exception("Something went wrong") }.collect { println(it) } sealed class DownloadStatus { data class Progress(val value: Double) : DownloadStatus() object Success : DownloadStatus() data class Error(val message: String) : DownloadStatus() }
79. flow<DownloadStatus> { emit(DownloadStatus.Progress(0.1)) try { throw IOException(“Something went wrong”)) } catch (e: IOException) { emit(DownloadStatus.Error(e.message)) } }.collect { println(it) } sealed class DownloadStatus { data class Progress(val value: Double) : DownloadStatus() object Success : DownloadStatus() data class Error(val message: String) : DownloadStatus() }
80. And completion?
81. launch { flow { // do stuff }.collect { value -> println(value) } }
82. launch { flow { // do stuff }.collect { value -> println(value) } } Flow gets instantiated
83. launch { flow { // do stuff }.collect { value -> println(value) } } collect gets called
84. launch { flow { // do stuff }.collect { value -> println(value) } } coroutine suspends here
85. launch { flow { // do stuff }.collect { value -> println(value) } } executed collect suspends here
86. launch { flow { // do stuff }.collect { value -> println(value) } } called for emission collect suspends here
87. launch { flow { // do stuff }.collect { value -> println(value) } } executed collect suspends here
88. launch { flow { // do stuff }.collect { value -> println(value) } } called for emission collect suspends here
89. launch { flow { // do stuff }.collect { value -> println(value) } } collect suspends here
90. launch { flow { // do stuff }.collect { value -> println(value) } }
91. launch { flow { // do stuff }.collect { value -> println(value) } handleCompletion() }
92. flow { // do stuff }.onCompletion { handleCompletion() }.collect { value -> println(value) } new in 1.3.0-M 2
93. Operator
94. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value -> println(value) }
95. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { }
96. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { } }
97. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector } } fun <T> flow(block: suspend FlowCollector<in T>.() -> Unit): Flow<T>
98. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector } }
99. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> } } }
100. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> } } } Flow<T>.collect
101. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> } } }
102. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value -> println(value) }
103. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value -> println(value) } fun <T, R> Flow<T>.map(…)
104. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value -> println(value) }
105. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value -> println(value) }
106. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> } } }
107. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> } } }
108. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> val r = transformer(value) } } }
109. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> val r = transformer(value) emit(r) } } }
110. fun <T, R> Flow<T>.map(transformer: suspend (value: T) -> R): Flow<R> { return flow { // this: FlowCollector collect { value -> val r = transformer(value) emit(r) } } } FlowCollector.emit(value)
111. flow { for (i in 0..5) { delay(100) emit(i) } }.map { value -> value * 2 }.collect { value println(value) }
112. Operator
113. Operator Observer Pattern
114. flow { for (i in 0..5) { delay(100) emit(i) } }.switchMap { value -> flow { emit(“first $value") delay(500) emit(“second $value") } }.collect { value -> 
 println(value) }
115. flow { for (i in 0..5) { delay(100) emit(i) } }.switchMap { value -> flow { emit(“first $value") delay(500) emit(“second $value") } }.collect { value -> 
 println(value) } Console output fi rst 0 fi rst 1 fi rst 2 fi rst 3 fi rst 4 fi rst 5
116. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { }
117. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { } }
118. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> } } }
119. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> } } }
120. flow { for (i in 0..5) { delay(100) emit(i) } }.switchMap { value flow { emit(“first $value") delay(500) emit(“second $value") } }.collect { value -> 
 println(value) }
121. flow { for (i in 0..5) { delay(100) emit(i) } }.switchMap { value -> flow { emit(“first $value") delay(500) emit(“second $value") } }.collect { value 
 println(value) }
122. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> } } }
123. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> val inner : Flow<R> = mapper(outerValue) } } }
124. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> val inner : Flow<R> = mapper(outerValue) inner.collect { value -> } } } }
125. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> val inner : Flow<R> = mapper(outerValue) launch { inner.collect { value -> } } } } }
126. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> val inner : Flow<R> = mapper(outerValue) launch { inner.collect { value -> emit(value) } } } } }
127. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { // this: FlowCollector collect { outerValue -> val inner : Flow<R> = mapper(outerValue) launch { inner.collect { value -> emit(value) } } } } } FlowCollector.emit(value)
128. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { collect { outerValue -> val inner : Flow<R> = mapper(outerValue) launch { inner.collect { value -> emit(value) } } } } }
129. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { var currentJob: Job? = null collect { outerValue -> val inner : Flow<R> = mapper(outerValue) currentJob = launch { inner.collect { value -> emit(value) } } } } }
130. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { var currentJob: Job? = null collect { outerValue -> val inner : Flow<R> = mapper(outerValue) currentJob?.cancelAndJoin() currentJob = launch { inner.collect { value -> emit(value) } } } } }
131. fun <T, R> Flow<T>.switchMap( mapper: suspend (value: T) -> Flow<R> ): Flow<R> { return flow { coroutineScope { var currentJob: Job? = null collect { outerValue -> val inner : Flow<R> = mapper(outerValue) currentJob?.cancelAndJoin() currentJob = launch { inner.collect { value -> emit(value) } } } } } }
132. Threading
133. interface CoroutineContext
134. interface CoroutineContext interface Job : CoroutineContext { public fun cancel(): Unit // a lot more… }
135. interface CoroutineContext interface Job : CoroutineContext { public fun cancel(): Unit // a lot more… } abstract class CoroutineDispatcher
136. interface CoroutineContext interface Job : CoroutineContext { public fun cancel(): Unit // a lot more… } abstract class CoroutineDispatcher Dispatchers.Main Dispatchers.Default Dispatchers.IO Dispatchers.Unconfined newSingleThreadContext()
137. interface CoroutineContext interface Job : CoroutineContext { public fun cancel(): Unit // a lot more… } abstract class CoroutineDispatcher Dispatchers.Main Dispatchers.Default Dispatchers.IO Dispatchers.Unconfined newSingleThreadContext() val context: CoroutineContext = Job() + Dispatchers.IO
138. public interface CoroutineScope { public val coroutineContext: CoroutineContext }
139. public interface CoroutineScope { public val coroutineContext: CoroutineContext } public inline fun CoroutineScope.cancel()
140. public interface CoroutineScope { public val coroutineContext: CoroutineContext } public inline fun CoroutineScope.cancel() public fun CoroutineScope.launch(...)
141. public interface CoroutineScope { public val coroutineContext: CoroutineContext } public inline fun CoroutineScope.cancel() public fun CoroutineScope.launch(...) val ViewModel.viewModelScope: CoroutineScope val Lifecycle.coroutineScope: LifecycleCoroutineScope
142. Threading (actually)
143. lifecycle.coroutineScope.launchWhenStarted { }
144. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
145. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread
146. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread
147. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread
148. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread
149. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
150. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { GlobalScope.launch { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
151. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { withContext(Dispatchers.IO) { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
152. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { withContext(Dispatchers.IO) { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } } IllegalStateException
153. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { withContext(Dispatchers.IO) { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
154. lifecycle.coroutineScope.launchWhenStarted { channelFlow<Int> { withContext(Dispatchers.IO) { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
155. lifecycle.coroutineScope.launchWhenStarted { channelFlow<Int> { // this: ProducerScope<Int> withContext(Dispatchers.IO) { // expensive operation emit(progress) // expensive operation emit(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
156. lifecycle.coroutineScope.launchWhenStarted { channelFlow<Int> { // this: ProducerScope<Int> withContext(Dispatchers.IO) { // expensive operation send(progress) // expensive operation send(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
157. lifecycle.coroutineScope.launchWhenStarted { channelFlow<Int> { // this: ProducerScope<Int> withContext(Dispatchers.IO) { // expensive operation send(progress) // expensive operation send(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread
158. lifecycle.coroutineScope.launchWhenStarted { channelFlow<Int> { // this: ProducerScope<Int> withContext(Dispatchers.IO) { // expensive operation send(progress) // expensive operation send(result) } }.map { it + 1 }.map { it.toString() }.collect { println(it) } } main thread IO thread
159. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 }.map { it.toString() }.collect { println(it) } }
160. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 } .flowOn(Dispatchers.IO) .map { it.toString() }.collect { println(it) } }
161. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 } .flowOn(Dispatchers.IO) .map { it.toString() }.collect { println(it) } } main thread IO thread
162. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 } .flowOn(Dispatchers.IO) .map { it.toString() }.collect { println(it) } } main thread IO thread
163. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 } .flowOn(Dispatchers.IO) .map { it.toString() }.collect { println(it) } } main thread IO thread
164. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation }.map { it + 1 } .flowOn(Dispatchers.IO) .map { it.toString() }.collect { println(it) } }
165. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation } .flowOn(Dispatchers.IO) .map { it + 1 } .flowOn(Dispatchers.Default) .map { it.toString() }.collect { println(it) } }
166. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation } .flowOn(Dispatchers.IO) .map { it + 1 } .flowOn(Dispatchers.Default) .map { it.toString() }.collect { println(it) } } main thread IO thread Default thread
167. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation } .flowOn(Dispatchers.IO) .map { it + 1 } .flowOn(Dispatchers.Default) .map { it.toString() }.collect { println(it) } } main thread IO thread Default thread
168. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation } .flowOn(Dispatchers.IO) .map { it + 1 } .flowOn(Dispatchers.Default) .map { it.toString() }.collect { println(it) } } main thread IO thread Default thread
169. lifecycle.coroutineScope.launchWhenStarted { flow<Int> { // expensive operation } .flowOn(Dispatchers.IO) .map { it + 1 } .flowOn(Dispatchers.Default) .map { it.toString() }.collect { println(it) } } main thread IO thread Default thread
170. Threading
171. Threading • collect lambda is always called on the initial CoroutineContext
172. Threading • collect lambda is always called on the initial CoroutineContext • fl owOn does only in fl uence the upstream
173. Threading • collect lambda is always called on the initial CoroutineContext • fl owOn does only in fl uence the upstream • nothing can change the context of downstream emissions
174. Some useful APIs
175. flowOf(1, 2, 3, 4)
176. flowOf(1, 2, 3, 4) listOf(1, 2, 3, 4).asFlow()
177. flowOf(1, 2, 3, 4) listOf(1, 2, 3, 4).asFlow() sequenceOf(1, 2, 3, 4).asFlow()
178. val someFunction: (() -> Result) = ...
179. val someFunction: (() -> Result) = ... someFunction.asFlow()
180. val someFunction: (() -> Result) = ... someFunction.asFlow() val doHttpRequest: (suspend () -> Result) = ...
181. val someFunction: (() -> Result) = ... someFunction.asFlow() val doHttpRequest: (suspend () -> Result) = ... doHttpRequest.asFlow()
182. val observable: Observable<Int> = Observable.just(1)
183. val observable: Observable<Int> = Observable.just(1) val flow: Flow<Int> = observable.toFlowable().asFlow()
184. val observable: Observable<Int> = Observable.just(1) val flow: Flow<Int> = observable.toFlowable().asFlow() val observable2: Observable<Int> = flow.asPublisher().toObservable()
185. RxJava Subject / Relay fl atMap() concatMap() switchMap() Flow channel.asFlow() fl atMapMerge() fl atMapConcat() switchMap()
186. RxJava & Flow map() fi lter() combineLatest() take() scan() retry() debounce() distinctUntilChanged() zip() takeUntil() reduce()
187. interface MyService { @GET(“{user}/books/favorite”) suspend fun getFavoriteBook(@Path(“user") userId: Int): Book }
188. new in 2.6.0 interface MyService { @GET(“{user}/books/favorite”) suspend fun getFavoriteBook(@Path(“user") userId: Int): Book }
189. flow { emit(userId1) emit(userId2) } interface MyService { @GET("{user}/books/favorite") suspend fun getFavoriteBook(@Path("user") userId: Int): Book }
190. flow { emit(userId1) emit(userId2) }.someOperator { userId -> val book = myService.getFavoriteBook(userId) book } interface MyService { @GET("{user}/books/favorite") suspend fun getFavoriteBook(@Path("user") userId: Int): Book }
191. flow { emit(userId1) emit(userId2) }.someOperator { userId -> val book = myService.getFavoriteBook(userId) book }.collect { book -> println(book) } interface MyService { @GET("{user}/books/favorite") suspend fun getFavoriteBook(@Path("user") userId: Int): Book }
192. flow { emit(userId1) emit(userId2) }.map { userId -> val book = myService.getFavoriteBook(userId) book }.collect { book -> println(book) } interface MyService { @GET("{user}/books/favorite") suspend fun getFavoriteBook(@Path("user") userId: Int): Book }
193. Summary • Flow: event stream • Observer Pattern • Backed by Coroutines
194. sockeqwe gabrielittner Questions?