Quick Introduction to Kotlin Coroutine for Android Dev

Quick introduction to Kotlin
Coroutine
Shuhei Shogen

What is this doc?
• Give you the basic idea of Coroutine
• Why is it needed?
• Syntax and its use case
• Coroutine in Android (only a little)

Overview of Kotlin
• Official page: https://kotlinlang.org/
• Developed by JetBrains Inc.
• Statically typed
• Latest version: 1.4.32 (as of 2021/4/13)
• https://www.slideshare.net/ShuheiShogen1/introduction-to-kotlin-
for-java-developer-168613075

Parallel processing
• A heavy process (like NW/DB access) might occupy a thread
• In case of Android, it will block the UI thread (-> ANR error)
• We need a way to process it in parallel with UI process
fun main() {
val data = fetchData() // Heavy process 1
saveData(data) // Heavy process 2
displayData(data)
}

Parallel processing is diﬃcult
• Threading?
• Difficult to deal with many threads
• Eat a lot of memory
fun main() {
val thread = thread { // Run the block in another thread
val data = fetchData()
saveData(data)
}
thread.join() // Wait until the thread is completed
displayData(data)
}

• Callback?
• Easily lead to complicated logics with deep nests (= callback hell)
// Modify it so that it will accept a callback method
fun fetchData(callback: Data -> Unit): Unit
fun saveData(data: Data, callback: Data -> Unit): Unit
fun main() {
fetchData { data -> { // Executed after fetchData is completed
saveData(data) { // Executed after saveData is completed
displayData(data)
}
}
}
}

• RxKotlin?
• Too many operators...
fun main() {
fetchData()
.flatMap { data -> {
saveData(data)
data
}
.subscribe { data -> displayData(data) }
}

• Coroutine
• Simple (we are using async/await syntax)
fun main() {
val deferredData = async { // "async" will start a coroutine and return a deferred object
val data = fetchData()
saveData(data)
data // Return value
}.await() // "Deferred<T>#await will wait until the target coroutine completes"
displayData(deferredData)
}

Kotlin Coroutine
• Coroutines are light-weight threads
• Suspendable/Cancellable in any part of the block
• Handy (-> Less chance of memory leak)
• Officially introduced in Kotlin 1.3

Thread 1
Coroutine v.s. Threading
Process 1
Threading
Coroutine
Process 3
IO wait IO wait
Thread 2 Process 2
Idle
Coroutine 1 Process 1 Process 3
Suspending Suspending
Coroutine 2 Process 2
IO wait Process 4
Suspending Process 4
Thread 1 Process 1 Process 2 Process 3 Process 4
Idle
Waste of resource
Eﬃcient use of threads :)

Set up
// build.gradle (app)
repositories {
mavenCentral()
}
// In case of a normal Kotlin app
dependencies {
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3'
testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.3'
}
// In case of Android
dependencies {
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3'
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0'
testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.3'
}

Our first Coroutine
fun main() {
runBlocking { // Create a CoroutineScope and wait until all the Coroutines finish (Don't use it in production)
launch { // Run a Coroutine
println("1")
delay(1000L) // Suspend the Coroutine for 1000 ms
println("2")
}
launch { // Run a Coroutine
println("3")
}
}
}
---
1
3
2

CoroutineScope
• Scope (Block) in which a Coroutine is allowed to be run
• Initialized with CoroutineContext / by runBlocking function
fun main() {
val job = Job() // Coroutine Job
val coroutineDispatcher = Dispatcher.IO // Indicate the Coroutine will be executed in (preserved) IO threads
val coroutineContext = coroutineDispatcher + Job() // Create a CoroutineContext by combining job and dispatcher
val scope = CoroutineScope(coroutineContext) // Create a CoroutineScope from CoroutineContext
scope.launch {
println("1")
delay(1000L)
println("2")
}
scope.launch {
println("3")
}
}

async / await
• Return a Deferred<T> object that contains the result of Coroutine (v.s. launch returns a Coroutine Job)
• Useful if you want the result value of a heavy process
fun main() {
runBlocking {
val deferred1 = async { // Deferred<Int>
delay(1000L)
1
}
val deferred2 = async {// Deferred<Int>
delay(2000L)
2
}
println(deferred1.await() + deferred2.await()) // Wait until both Coroutines are completed (for 2000 ms)
}
}
---
3

Suspending function
• A function that can be suspended in the context of Coroutine
• Suspending function can be called only either in a Coroutine or in (another) suspending function
• delay() and await() are suspending functions
// Wrong
fun simulateWorkload() {
delay(1000L) // Compliration error
}
---
// Correct
suspend fun simulateWorkload() {
delay(1000L)
}
GlobalScope.launch {
simulateWorkload() // A suspending function can be called in a Coroutine
}

Test your Coroutine
• Use TestCoroutineDispatcher
class MyRepository(
private val coroutineDispatcher: CoroutineDispatcher
) {
fun fetchData(): List<Data> {
withContext(coroutineDispatcher) {
// Do heavy IO process
return dataList
}
}
}
class MyRepositoryTest {
private val testDispatcher = TestCoroutineDispatcher()
@Test
fun testFetchData() {
testDispatcher.runBlockingTest {
// Mock dependencies if needed
val repository = MyRepository(testDispatcher)
val expected = ... // Define the expected value
val actual = repository.fetchData
assertThat(expected, `is`(actual))
}
}
}

Coroutine in Android app
• AndroidX lifecycle has viewModelScope in ViewModel
• This CoroutineScope will be automatically cancelled when the ViewModel is destroyed
class MyViewModel(
private val myRepository: MyRepository,
private val coroutineDispatcher: CoroutineDispatcher = Dispatcher.Main
) : ViewModel {
fun loadData() {
viewModelScope.launch { // This scope will be cancelled when MyViewModel is destroyed (= Less chance of memory leak)
val someData = myRepository.fetchData()
// UI update
}
}
}
class MyRepository(
private val coroutineDispatcher: CoroutineDispatcher = Dispatcher.IO
)
suspend fun fetchData(): List<SomeData> {
withContext(coroutineDispatcher) { // Change CoroutineContext to change the thread to be run
// ...
}
}
}

Take away
• Corourtines can be used to handle parallel processing easily
• Android has some supports for Coroutine

Topics not covered in these slides
• Detail explanation about CoroutineScope/CoroutineContext/
CoroutineDispatcher
• Error handling in Coroutine
• Kotlin Flow and its Android support

Referrences
• Kotlin Coroutine guide
• https://kotlinlang.org/docs/coroutines-guide.html
• Kotlin coroutines on Android
• https://developer.android.com/kotlin/coroutines
• 詳解 Kotlin Coroutines
• https://zenn.dev/at_sushi_at/books/edf63219adfc31

Quick Introduction to Kotlin Coroutine for Android Dev

More Related Content

What's hot (20)

Similar to Quick Introduction to Kotlin Coroutine for Android Dev (20)

Recently uploaded (20)

Quick Introduction to Kotlin Coroutine for Android Dev