Async Adventures Part I: Deciphering Kotlin Coroutines for a Smooth Coding Journey 🚗🌍

From Poetry to Programming: My Personal Code Odyssey.

Before the allure of writing and dreaming codes ensnared me (I get nightmares at times), I reveled in the world of words as a storyteller and poet. When I stepped onto the tech stage, it felt like a legion of terminologies was challenging me to a duel. Remembering my high school days, where turning complex science concepts into tales made them more palatable, I wielded storytelling as my sword once more. This narrative technique became my beacon and enchanted my students during my tenure as a tech bootcamp instructor in the U.S.

So, allow me to invite you on a narrative journey into the enthralling domain of Kotlin Coroutines!

Welcome to the exciting world of Kotlin Coroutines! Imagine you have many friends (tasks) trying to share their stories at the same time without interrupting one another. That’s what Coroutines help us achieve in our code!

🎯 A Simple Look at Coroutines

In coding, sometimes, we want our programs to do multiple things at once. Coroutines help us organize this chaos. Think of them as friendly guides, helping our tasks take turns so that they don’t talk over each other. Unlike other methods, which can be heavy and confusing, Coroutines are light and easy!

Other coding tools like Callbacks and Futures can make our code messy, but with Coroutines, we keep things neat and easy to read.

🛑 Understanding Asynchronous Programming

Imagine a park where kids (our tasks) play different games at the same time. That’s Asynchronous Programming. Each kid is doing their own thing without waiting for the others to finish.

🧳 Note: In simpler terms, it’s about doing many things at once in our code.

🚗 Meet Kotlin Coroutines: Our Friendly Guide

Coroutines help our tasks wait their turn without stopping everything else. They tell one task, “Hey, take a short break while others work,” and then bring it back when it’s its turn.

🧳 Note: This “take a short break” magic comes from a special word suspend. When we see it in our code, it means that the function can pause and resume later.

suspend fun enjoyTheView() {
    println("Enjoying the beautiful scenery!")
}

Before embarking further, equip your coding backpack by adding these potions (dependencies) to build.gradle (Module :app) and sync:

dependencies {
//Other dependencies
...

//You can upgrade to 1.7.1
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2' 
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2'
}

🌉 Writing Our First Coroutine

To start a Coroutine, we use launch. Think of it as starting a new adventure for our tasks. The suspend word lets our functions take short breaks.

🧳 Note: Using words like launch and suspend, we can easily control how our tasks run.

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        launch {
            enjoyTheView()
        }
    }
}

📖 About runBlocking: Think of runBlocking as a campsite. Everything inside it waits until all tasks (or adventures) are done. In Android, it’s mostly for quick tests or examples, not for real apps! It blocks the current thread until the coroutine inside it completes. This is not recommended for Android’s onCreate method as it can lead to UI freezing.

🗺️ Exploring More with Coroutines

Using Coroutines, we can easily make tasks wait or run immediately. For example, with delay(), we can make a task wait a bit before continuing.

suspend fun exploreTheLand() {
    delay(2000L) // Wait for 2 seconds
    println("Discovered a new place!")
}

fun main() = runBlocking {
    launch {
        exploreTheLand()
    }
    println("Starting our journey!")
}

If you try the example above, you’ll first see “Starting our journey!” and, after a 2-second wait, “Discovered a new place!”.

📖 Updating UI in Android: In real Android apps, we might want to update our screen (or UI) after a task. Using Coroutines, we can do this with withContext(Dispatchers.Main). This tells our app, "Hey, update the screen now!"

For instance, in an Android Activity:

GlobalScope.launch {
    val data = fetchData()  // Some function to fetch data
    withContext(Dispatchers.Main) {
        updateUI(data)  // Function to update your app’s screen
    }
}

Remember, to update the UI, always use withContext(Dispatchers.Main).

Also, remember to be careful when using GlobalScope as it’s not tied to any lifecycle, and the launched coroutines will not be canceled when your activity is destroyed. It’s often better to use a scope tied to the activity lifecycle like lifecycleScope or viewModelScope.

You would need to add these dependencies in your build.gradle (Module :app) and sync: (We’ll talk more about this in a subsequent chapter.)

 implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2'
 implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.2'

🎬 Playing Around With Wholesome Coroutine Adventure

Let’s imagine you’re orchestrating a grand festival in the village square. This festival has three main events: a dance performance, a magic show, and fireworks. We’ll use Kotlin Coroutines to make sure each event happens seamlessly.

import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers.Main

fun main() = runBlocking {

    // Dance Performance
    val dancePerformance = async {
        startDancePerformance()
    }

    // Magic Show
    launch {
        magicShow()
    }

    // Wait for the dance to finish before starting fireworks
    dancePerformance.await()

    // Fireworks
    withContext(Main) {
        grandFireworks()
    }

    println("What a magical festival!")
}

suspend fun startDancePerformance(): String {
    delay(2000L) // The dance performance lasts 2 seconds
    println("💃 The dance performance was mesmerizing!")
    return "Dance Done!"
}

suspend fun magicShow() {
    delay(1000L) // The magic show takes a second to mesmerize the audience
    println("🎩 Wow, did that magician just pull out a rabbit?")
}

suspend fun grandFireworks() {
    delay(500L) // Half a second pause before the grand fireworks
    println("🎆 Boom! The sky is painted with colors!")
}

Breaking Down Our Festival:

1. Asynchronous Programming: Our festival is bustling with multiple events happening. Some can happen at the same time (dance and magic show), while some wait for others (fireworks wait for the dance). This is the essence of asynchronous programming.

2. Using Coroutines: We use launch and async to start our events. launch starts an event without waiting for it to finish while async starts an event and lets us await its result.

3. Suspend Functions: Notice the word suspend before our functions? These allow our events to take breaks (like the delays in our events) without stopping other events.

4. Updating the Main Event: Our grand fireworks, which are the main event, are executed on the main thread (withContext(Main)) to ensure everyone in the village witnesses them.

5. Running the Festival: We wrap everything in runBlocking to ensure our main function doesn't finish before all our events are completed.

When you run the example, you’ll see the magic show start, followed by the dance, and once the dance ends, the grand fireworks illuminate the sky, concluding our festival.

🌅 What’s Next?

The Weekend Nerd! 😉

There’s so much more to explore, like “Coroutine Scopes” and “Dispatchers.” But for now, let’s relax and enjoy( the weekend 🤓) what we’ve learned.

Wrapping Up: Mixing fun stories with code makes learning Kotlin Coroutines an exciting journey. Stick around for more adventures and happy coding! 🎒🗺️