Coroutines for async networking in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to launch a coroutine in the main thread.

Android Kotlin

GlobalScope.launch(Dispatchers.[1]) {
    // network call here
}

Drag options to blanks, or click blank then click option'

ADefault

BIO

CUnconfined

DMain

Attempts:

3 left

💡 Hint

Common Mistakes

Using Dispatchers.IO for UI work causes errors.

Forgetting to specify a dispatcher.

Use Dispatchers.Main to run coroutines on the main thread, suitable for UI updates.

2fill in blank

medium

Complete the code to make a network call asynchronously using suspend function.

Android Kotlin

suspend fun fetchData() : String {
    return withContext(Dispatchers.[1]) {
        // simulate network call
        "data"
    }
}

Drag options to blanks, or click blank then click option'

AMain

BIO

CDefault

DUnconfined

Attempts:

3 left

💡 Hint

Common Mistakes

Using Dispatchers.Main causes app to freeze.

Using Dispatchers.Default is less efficient for IO.

Use Dispatchers.IO for blocking IO tasks like network calls to avoid blocking the main thread.

3fill in blank

hard

Fix the error in the coroutine builder to properly handle exceptions.

Android Kotlin

GlobalScope.launch(Dispatchers.IO) {
    try {
        val result = fetchData()
        withContext(Dispatchers.[1]) {
            // update UI with result
        }
    } catch (e: Exception) {
        // handle error
    }
}

Drag options to blanks, or click blank then click option'

AMain

BIO

CDefault

DUnconfined

Attempts:

3 left

💡 Hint

Common Mistakes

Updating UI on Dispatchers.IO causes crashes.

Not catching exceptions in coroutines.

UI updates must happen on the main thread, so use Dispatchers.Main inside withContext.

4fill in blank

hard

Fill both blanks to create a coroutine scope and launch a coroutine for network call.

Android Kotlin

val scope = CoroutineScope(Dispatchers.[1] + Job())
scope.[2] {
    val data = fetchData()
    // process data
}

Drag options to blanks, or click blank then click option'

AIO

Blaunch

CMain

Dasync

Attempts:

3 left

💡 Hint

Common Mistakes

Using async when no result is needed.

Using Main dispatcher for network calls.

Use Dispatchers.IO for network calls and launch to start a coroutine without returning a result.

5fill in blank

hard

Fill all three blanks to create an async coroutine that fetches data and awaits the result.

Android Kotlin

val deferred = CoroutineScope(Dispatchers.[1]).[2] {
    fetchData()
}
val result = deferred.[3]()

Drag options to blanks, or click blank then click option'

AMain

BIO

Cawait

Dasync

Attempts:

3 left

💡 Hint

Common Mistakes

Calling await() on a non-Deferred object.

Using Main dispatcher for network calls.

Use Dispatchers.IO for network, async to start coroutine returning Deferred, and await to get result.

Practice

1. What is the main benefit of using coroutines for network calls in Android apps?

easy

A. They replace the need for any background threads.

B. They make the app run faster by using more CPU cores.

C. They automatically cache network data for offline use.

D. They prevent the app's screen from freezing during network tasks.

Solution

1. Step 1: Understand what happens during network calls

   Network calls can take time and if done on the main thread, they freeze the UI.

2. Step 2: Role of coroutines in network calls

   Coroutines run network tasks in the background, keeping the UI responsive.

3. Final Answer:

   They prevent the app's screen from freezing during network tasks. -> Option D

4. Quick Check:

   Coroutines keep UI responsive = D [OK]

Hint: Coroutines keep UI smooth by running tasks in background [OK]

Common Mistakes:

• Thinking coroutines speed up CPU usage
• Believing coroutines cache data automatically
• Assuming coroutines remove all threading needs

2. Which of the following is the correct way to start a coroutine for a network call on a background thread?

easy

A. launch(Dispatchers.Main) { fetchData() }

B. launch(Dispatchers.Default) { updateUI() }

C. launch(Dispatchers.IO) { fetchData() }

D. launch { fetchData() }

Solution

1. Step 1: Identify dispatcher for background network tasks

   Dispatchers.IO is designed for blocking IO tasks like network calls.

2. Step 2: Match correct coroutine launch syntax

   launch(Dispatchers.IO) { fetchData() } runs fetchData() on IO thread pool.

3. Final Answer:

   launch(Dispatchers.IO) { fetchData() } -> Option C

4. Quick Check:

   Network calls use Dispatchers.IO = B [OK]

Hint: Use Dispatchers.IO for network calls in launch [OK]

Common Mistakes:

• Using Dispatchers.Main for network calls
• Confusing Dispatchers.Default with IO
• Omitting dispatcher and running on main thread

3. What will be the output of this code snippet?

fun main() = runBlocking {
  launch(Dispatchers.IO) {
    println("Network call started")
  }
  println("Main thread continues")
}

medium

A. Main thread continues\nNetwork call started

B. Only Network call started

C. Network call started\nMain thread continues

D. Only Main thread continues

Solution

1. Step 1: Understand runBlocking and launch behavior

   runBlocking blocks main thread until all coroutines complete. launch starts coroutine asynchronously.

2. Step 2: Order of print statements

   "Main thread continues" prints immediately; "Network call started" prints shortly after from IO dispatcher.

3. Final Answer:

   Main thread continues\nNetwork call started -> Option A

4. Quick Check:

   launch is async, main prints first = C [OK]

Hint: launch runs async, main prints before coroutine output [OK]

Common Mistakes:

• Assuming launch blocks main thread
• Expecting network print before main print
• Ignoring coroutine dispatchers

4. Identify the error in this coroutine code snippet:

GlobalScope.launch(Dispatchers.IO) {
  val data = fetchData()
  textView.text = data
}

medium

A. fetchData() must be called on Dispatchers.Main.

B. Cannot update UI from Dispatchers.IO thread.

C. GlobalScope cannot be used with launch.

D. textView.text should be assigned inside fetchData().

Solution

1. Step 1: Check thread for UI update

   UI elements like textView must be updated on the main thread.

2. Step 2: Identify misuse of Dispatchers.IO

   Dispatchers.IO runs on background thread; updating UI here causes error.

3. Final Answer:

   Cannot update UI from Dispatchers.IO thread. -> Option B

4. Quick Check:

   UI updates require Dispatchers.Main = A [OK]

Hint: Update UI only on Dispatchers.Main thread [OK]

Common Mistakes:

• Updating UI on background thread
• Misusing GlobalScope without lifecycle awareness
• Calling fetchData() on main thread unnecessarily

5. You want to fetch user data from the network and then update the UI with the result. Which coroutine structure correctly handles this?

hard

A. launch(Dispatchers.Main) { val data = withContext(Dispatchers.IO) { fetchUser() }; updateUI(data) }

B. launch(Dispatchers.IO) { val data = fetchUser(); updateUI(data) }

C. launch { val data = fetchUser(); updateUI(data) }

D. launch(Dispatchers.Default) { val data = fetchUser(); updateUI(data) }

Solution

1. Step 1: Identify correct dispatcher for network call

   Network call fetchUser() should run on Dispatchers.IO to avoid blocking UI.

2. Step 2: Ensure UI update runs on main thread

   updateUI(data) must run on Dispatchers.Main to safely update UI elements.

3. Step 3: Analyze launch(Dispatchers.Main) { val data = withContext(Dispatchers.IO) { fetchUser() }; updateUI(data) } structure

   launch on Main dispatcher, inside withContext(Dispatchers.IO) runs fetchUser(), then UI updates on Main.

4. Final Answer:

   launch(Dispatchers.Main) { val data = withContext(Dispatchers.IO) { fetchUser() }; updateUI(data) } -> Option A

5. Quick Check:

   Network on IO, UI on Main = A [OK]

Hint: Use withContext(IO) inside Main launch for network + UI update [OK]

Common Mistakes:

• Updating UI on IO or Default dispatcher
• Running network call on Main dispatcher directly
• Not switching context for network call