Clean Architecture in Action [part 2]- Coroutines - Saeed Masoumi

https://youtu.be/Ap-rt3DDJpA

Transcript

1. Clean Architecture in Action Part 2 - Coroutines Saeed Masoumi
2. Async Programming
3. Threading • Threads aren’t cheap • Allocate and initialize a large block of memory • Context switches are costly
4. Threading • Threads aren’t cheap • Threads aren’t easy to debug
5. Threading • Threads aren’t cheap • Threads aren’t easy to debug • Threads aren’t infinite
6. Threading • Threads aren’t cheap • Threads aren’t easy to debug • Threads aren’t infinite
7. Callbacks fun sendFavoriteSong(/*..*/) { prepareAsync { sendAsync { //... } } }
8. Callbacks fun sendFavoriteSong(/*..*/) { prepareAsync { sendAsync { anotherAsync { //.. } } } }
9. Callbacks fun sendFavoriteSong(/*..*/) { prepareAsync { sendAsync { anotherAsync { anotherAsync { //... } } } } }
10. Callbacks fun sendFavoriteSong(/*..*/) { prepareAsync { sendAsync { anotherAsync { anotherAsync { anotherHellAsync { } } } } } }
11. Callbacks • Callbacks hell (A.K.A Christmas tree)
12. Callbacks • Callbacks hell (A.K.A Christmas tree) • Complicated error handling
13. Callbacks • Callbacks hell (A.K.A Christmas tree) • Complicated error handling
14. Promises task { 1 + 1 } then { i -> "result: $i" } success { msg -> println(msg) }
15. Promises • Compositional model with chained calls • Error handling can be complicated
16. Reactive Extensions • Stream and Observable • Nice error handling
17. Coroutines
18. Coroutines • Lightweight threads • Suspendable computation • Platform independent
19. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } Hello, World!
20. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } • Launch new coroutine in background and continue • Returns a job
21. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } CoroutineScope with application lifetime
22. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } Non-blocking delay
23. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) }
24. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } Prints Hello,
25. Coroutines fun main() { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) }
26. Coroutines fun main() = runBlocking { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") delay(2000L) } Blocks until the coroutine inside runBlocking completes
27. Coroutines fun main() = runBlocking { val job = GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") job.join() } wait until child coroutine completes
28. Coroutines fun main() = runBlocking { GlobalScope.launch { delay(1000L) println("World!") } println("Hello,") } fun main() = runBlocking { launch { delay(1000L) println("World!") } println("Hello,") } Hello, Hello, World!
29. Structured Concurrency
30. Structured Concurrency Ran out of memory Forget to keep reference Too long delay Join them? • Threads are global
31. Structured Concurrency • Threads are global • GlobalScope is global too!
32. Structured Concurrency • Threads are global • GlobalScope is global too!
33. Structured Concurrency fun downloadAPKs(packageNames: List<String>) { packageNames.forEach { val url = findUrl(it) GlobalScope.launch { download(url) //... } } }
34. Structured Concurrency fun downloadAPKs(packageNames: List<String>) { packageNames.forEach { val url = findUrl(it) GlobalScope.launch { download(url) //... } } } Crash!!!
35. Structured Concurrency So instead of launching in global scope, run in a specific scope
36. Structured Concurrency suspend fun downloadAPKs(packageNames: List<String>) = coroutineScope { packageNames.forEach { val url = findUrl(it) launch { download(url) //... } } }
37. Structured Concurrency suspend fun downloadAPKs(packageName: List<String>) = coroutineScope { packageName.forEach { val url = findUrl(it) launch { download(url) //... } } }
38. Structured Concurrency suspend fun downloadAPKs(packageName: List<String>) = coroutineScope { packageName.forEach { val url = findUrl(it) launch { download(url) //... } } } Crash Cancels Waits for all previous “launch” to complete No Job leak anymore
39. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") } Task from coroutine scope Task from runBlocking Task from nested launch Coroutine scope is over
40. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") } launch new coroutine in the scope of runBlocking
41. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") } - Creates a new coroutine scope - Does not block the current thread while waiting for all children to complete.
42. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") } Waits nested launch completes
43. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") }
44. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } println("Coroutine scope is over") } suspend fun doWork() { }
45. Structured Concurrency fun main() = runBlocking { launch { delay(200L) println("Task from runBlocking") } doWork() println("Coroutine scope is over") } suspend fun doWork() = coroutineScope { launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") }
46. Cancellation
47. Cancellation fun main(args: Array<String>) = runBlocking { val job = launch { doWork() } delay(1000) job.cancelAndJoin() } private suspend fun doWork() { try { delay(2000L) } catch (e: Exception) { println(e) } } kotlinx.coroutines.JobCancellationException: Job was cancelled; job=StandaloneCoroutine{Cancelling}
48. Dispatchers • Like RxJava’s Schedulers • IO • Main (Android, JavaFX, Swing) • Default • Unconfined
49. Async/Await
50. Async/Await suspend fun calculateOne(): Int { delay(1000L) return 11 } suspend fun calculateTwo(): Int { delay(1000L) return 22 } Concurrent Execution !?
51. Async/Await fun main() = runBlocking { val time = measureTimeMillis { val one = async { calculateOne() } val two = async { calculateTwo() } println("The answer is ${one.await() + two.await()}") } println("Completed in $time ms") } ~ 1 sec Like launch but return Deferred
52. Async/Await fun main() = runBlocking { val time = measureTimeMillis { val one = async(start = CoroutineStart.LAZY) { calculateOne() } val two = async(start = CoroutineStart.LAZY) { calculateTwo() } println("The answer is ${one.await() + two.await()}") } println("Completed in $time ms") } ~ 2 sec
53. Async/Await fun main() = runBlocking { val time = measureTimeMillis { val one = async(start = CoroutineStart.LAZY) { calculateOne() } val two = async(start = CoroutineStart.LAZY) { calculateTwo() } one.start() two.start() println("The answer is ${one.await() + two.await()}") } println("Completed in $time ms") } ~ 1 sec
54. Experimental Features • Channels • Select Expression
55. Coroutines + Android
56. Back to our App
57. Domain interface TVShowRepository { fun getAll(): List<TVShow> }
58. Domain Layer interface TVShowRepository { suspend fun getAll(): List<TVShow> }
59. Domain Layer interface TVShowRepository { suspend fun getAll(): List<TVShow> } What about exceptions? - Try/Catch - Either
60. Either https://arrow-kt.io/docs/datatypes/either/ sealed class Either<out A, out B> : EitherOf<A, B>
61. Either https://arrow-kt.io/docs/datatypes/either/ sealed class Either<out A, out B> : EitherOf<A, B> - Call it “left” - Put Error/Exception classes in this Generic
62. Either https://arrow-kt.io/docs/datatypes/either/ sealed class Either<out A, out B> : EitherOf<A, B> - Call it “right” - The success Value
63. Domain Layer interface TVShowRepository { suspend fun getAll(): List<TVShow> }
64. Domain Layer interface TVShowRepository { suspend fun getAll(): Either<Error, List<TVShow>> } sealed class Error(val msg: String) { class NetworkConnection(msg: String) : Error(msg) //.. sealed class Feature(msg: String) : Error(msg) { class UnreachableTVShow : Feature("UnReachable") //.. } }
65. Domain Layer when (error) { is NetworkConnection -> { /*..*/} is UnreachableTVShow -> { /*..*/} else -> { /*..*/} } Looks better?
66. Data Layer override suspend fun getAll(api: api) { try { val users = api.getAll().await() return Either.right(users) } catch (e: Exception) { return Either.left(mapToError(e)) } } https://github.com/gildor/kotlin-coroutines-retrofit
67. What happened? https://github.com/gildor/kotlin-coroutines-retrofit • All non-UI layers are now implemented with suspend functions • Sequential programming • More readable code
68. But… • Structured concurrency on UI layer
69. ViewModel abstract class BaseViewModel : ViewModel()
70. ViewModel abstract class BaseViewModel : ViewModel(), CoroutineScope
71. ViewModel abstract class BaseViewModel : ViewModel(), CoroutineScope { protected val job: Job = Job() override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job override fun onCleared() { super.onCleared() job.cancel() } }
72. ViewModel abstract class BaseViewModel : ViewModel(), CoroutineScope { protected val job: Job = Job() override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job override fun onCleared() { super.onCleared() job.cancel() } } Plus operator Launch on main thread Job will reference to all launches
73. ViewModel class TVShowViewModel(val repository: TVShowRepository) : BaseViewModel() { fun load() = launch { val result = async(Dispatchers.IO) { repository.getAll() }.await() //do whatever you want with result } }
74. Clean Architecture in Action twitter.com/s_masoumi
 
 github.com/SaeedMasoumi