Kotlin Coroutines Beyond async/await Bolot Kerimbaev 

Problem • We want async • Async is hard 

Problem val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2) displayImage(result) 

Solutions • AsyncTask • Callback • Observable, Reactive • Future, Promise 

Callback loadImageCallback(url1) { image1 -> .loadImageCallback(url2) { image2 -> combineImages(image1, image2) { displayImage(result) } } } 

Callback Hell peerConnection.setRemoteDescription(object: SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { peerConnection.createAnswer(object : SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { } override fun onCreateSuccess(sdp: SessionDescription?) { peerConnection.setLocalDescription(object : SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { } override fun onCreateSuccess(sdp: SessionDescription?) { // TODO: get audio/video tracks } override fun onCreateFailure(error: String?) { } }, sdp) } override fun onCreateFailure(error: String?) { } }, mediaConstraints) } override fun onCreateSuccess(sdp: SessionDescription?) { } override fun onCreateFailure(error: String?) { } }, sessionDescription) 

Rx loadImageRx(url1) .zipWith(loadImageRx(url2), ::combineImages) .subscribe() 

Rx loadImageRx(url1) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .zipWith(loadImageRx(url2), ::combineImages) .subscribe() 

Sequential val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2) 

Coroutines val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await()) 

async/await val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await()) 

async/await 

Behind the Scenes val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2) displayImage(result) 

Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) } 

Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) } 

Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) } 

Behind the Scenes class Continuation(val label: Int, val context: Map, val error: Throwable?) 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 

Behind the Scenes fun load() = load(Continuation(0, emptyMap(), null)) 

Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) } 

Continuation public interface Continuation { public val context: CoroutineContext public fun resume(value: T) public fun resumeWithException(exception: Throwable) } 

Retrofit suspend fun Call.await(): T { return suspendCoroutine { cont -> enqueue(object: Callback { override fun onResponse(call: Call?, response: Response) { if (response.isSuccessful) { val body = response.body() ?: return cont.resumeWithException(NullPointerException()) cont.resume(body) } else { cont.resumeWithException(ApiError()) } } override fun onFailure(call: Call?, t: Throwable) { cont.resumeWithException(t) } }) } } 

Retrofit suspend fun Call.await(): T { return suspendCoroutine { cont -> enqueue(object: Callback { override fun onResponse(call: Call?, response: Response) { if (response.isSuccessful) { val body = response.body() ?: return cont.resumeWithException(NullPointerException()) cont.resume(body) } else { cont.resumeWithException(ApiError()) } } override fun onFailure(call: Call?, t: Throwable) { cont.resumeWithException(t) } }) } } 

Retrofit dependencies { implementation 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines- experimental-adapter:1.0.0' } Retrofit.Builder() .baseUrl(baseUrl) .client(client) .addConverterFactory(gsonConverterFactory) .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() 

Retrofit interface ApiService { @GET fun loadTweets(): Call> } 

Retrofit interface ApiService { @GET fun loadTweets(): Call> } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred> } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred> } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred> } launch { val tweets = service.loadTweets() displayTweets(tweets.await()) } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred> } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred>> } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred>> } launch { val deferred = service3.loadTweets() val response = deferred.await() if (response.isSuccessful) { response.body()?.let { displayTweets(it) } } } 

Retrofit interface ApiService { @GET fun loadTweets(): Deferred>> } launch { val deferred = service3.loadTweets() val response = deferred.await() if (response.isSuccessful) { response.body()?.let { displayTweets(it) } } } 

async public fun async( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, onCompletion: CompletionHandler? = null, block: suspend CoroutineScope.() -> T ): Deferred 

async public fun async( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, onCompletion: CompletionHandler? = null, block: suspend CoroutineScope.() -> T ): Deferred 

await override suspend fun await(): T = awaitInternal() as T 

Coroutine Builders val job = launch { } val deferred = async { } val result = runBlocking { } 

launch/join val jobs = List(100_000) { launch { delay(5000) print(".") } } jobs.forEach { it.join() } 

launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() } 

launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() } 

launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() } 

launch/join val jobs = List(100_000) { launch(CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() } 

Coroutine Context val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await()) 

Coroutine Context public interface CoroutineContext { public operator fun get(key: Key): E? public fun fold(initial: R, operation: (R, Element) -> R): R public operator fun plus(context: CoroutineContext): CoroutineContext public fun minusKey(key: Key<*>): CoroutineContext public interface Element : CoroutineContext public interface Key } 

Coroutine Context log("Thread: ${Thread.currentThread().name}") log("Context: $coroutineContext") log("Job: ${coroutineContext[Job]}") log("Interceptor: ${coroutineContext[ContinuationInterceptor]}") 

Coroutine Context Thread: ForkJoinPool.commonPool-worker-1
 Context: [DeferredCoroutine{Active}@424f90d, CommonPool]
 Job: DeferredCoroutine{Active}@424f90d
 Interceptor: CommonPool Thread: ForkJoinPool.commonPool-worker-2
 Context: [DeferredCoroutine{Active}@4ae30c2, CommonPool]
 Job: DeferredCoroutine{Active}@4ae30c2
 Interceptor: CommonPool 

Retry • If at first you don’t succeed… • …Redefine success? • …Retry? 

Retry val image1 = loadImage(url1) val image2 = loadImage(url1) composeImages(image1, image2) 

Retry val image1 = retryIO { loadImage(url1) } val image2 = retryIO(times = 3) { loadImage(url1) } composeImages(image1, image2) 

Retry val image1 = retryIO { loadImage(url1) } val image2 = retryIO(times = 3) { loadImage(url1) } composeImages(image1, image2) 

retryIO suspend fun retryIO( times: Int = Int.MAX_VALUE, initialDelay: Long = 100, // 0.1 second maxDelay: Long = 1000, // 1 second factor: Double = 2.0, block: suspend () -> T): T { var currentDelay = initialDelay repeat(times - 1) { try { return block() } catch (e: IOException) { Timber.e(e, "retryIO") } delay(currentDelay) currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay) } return block() // last attempt } 

Lifecycle var job: Job? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) job = launch(UI) { // ... } } override fun onDestroy() { super.onDestroy() job?.cancel() } 

Lifecycle var job: Job? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) job = launch(UI) { // ... } } override fun onDestroy() { super.onDestroy() job?.cancel() } 

Channels val channel = Channel() launch(CommonPool) { repeat(42) { channel.send(it)} } launch(UI) { for (i in channel) log("$i") } 

Channels public interface Channel : SendChannel, ReceiveChannel public interface SendChannel { public suspend fun send(element: E) public fun close(cause: Throwable? = null): Boolean } public interface ReceiveChannel { public suspend fun receive(): E public operator fun iterator(): ChannelIterator } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) } 

Channels val channel: Channel = Channel() sendButton.setOnClickListener { launch(UI) { val text = usernameEditText.text.toString() channel.send(text) } } 

Channels launch(UI) { for (string in channel) { resultTextView.text = string } } 

Channels var job: Job? = null override fun onViewCreated(view: View, savedInstanceState: Bundle?) { job = launch(UI) { for (string in channel) { resultTextView.text = channel.receive() } } } override fun onDestroyView() { super.onDestroyView() job?.cancel() } 

More Coroutines • Actors • Mutexes • Sequences 

Sequences val fibonacci = buildSequence { yield(1) var cur = 1 var next = 1 while(true) { yield(next) val tmp = cur + next cur = next next = tmp } } fibonacci.take(5).map { it*it } 

Kotlin 1.3 • No longer “experimental” • buildSequence and buildIterator moved to the kotlin.sequences package • Simplified Continuation, only one method resumeWith(result:SuccessOrFailure) • KT-16908 Support callable references to suspending functions • KT-18559 Serializability of all coroutine-related classes