withContext for thread switching in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens to the UI when using withContext(Dispatchers.IO)?

Consider this Kotlin coroutine snippet in an Android app:

GlobalScope.launch(Dispatchers.Main) {
  val data = withContext(Dispatchers.IO) {
    fetchDataFromNetwork()
  }
  updateUI(data)
}

What is the effect of using withContext(Dispatchers.IO) here?

Android Kotlin

GlobalScope.launch(Dispatchers.Main) {
  val data = withContext(Dispatchers.IO) {
    fetchDataFromNetwork()
  }
  updateUI(data)
}

A The network call runs on a background thread, keeping the UI responsive while updating UI on the main thread.

B The network call runs on the main thread, causing the UI to freeze until it finishes.

C The UI updates happen on the IO thread, which can cause crashes.

D The entire coroutine runs on the IO thread, so UI updates are delayed.

💡 Hint

Think about which thread handles UI updates and which handles long-running tasks.

Using withContext(Dispatchers.IO) switches the coroutine to a background thread for the network call, preventing UI blocking. After that, it switches back to the main thread to update the UI safely.

🧠 Conceptual

intermediate

What does withContext do in Kotlin coroutines?

Choose the best description of what withContext does in Kotlin coroutines.

A It cancels the coroutine and all its child coroutines.

B It creates a new coroutine that runs concurrently with the current one.

C It pauses the coroutine indefinitely until manually resumed.

D It switches the coroutine context to a different thread or dispatcher for the block of code inside it.

💡 Hint

Think about how you run code on different threads inside a coroutine.

withContext temporarily changes the coroutine's context (like thread or dispatcher) for the code block, then returns to the original context.

❓ lifecycle

advanced

What happens if you call withContext(Dispatchers.Main) inside withContext(Dispatchers.IO)?

Given this nested coroutine code:

withContext(Dispatchers.IO) {
  // background work
  withContext(Dispatchers.Main) {
    updateUI()
  }
}

What is the behavior of this code?

Android Kotlin

withContext(Dispatchers.IO) {
  // background work
  withContext(Dispatchers.Main) {
    updateUI()
  }
}

A It causes a deadlock because switching threads inside withContext is not allowed.

B The code switches to IO thread, then back to Main thread to update UI safely.

C The updateUI runs on the IO thread, risking UI crashes.

D The entire block runs on the Main thread ignoring the IO dispatcher.

💡 Hint

Think about how withContext can be nested to switch threads multiple times.

withContext can be nested to switch contexts multiple times. Here, it runs background work on IO, then switches to Main thread to update UI safely.

📝 Syntax

advanced

Identify the syntax error in this coroutine with withContext usage

What is wrong with this Kotlin code snippet?

launch(Dispatchers.Main) {
  val result = withContext(Dispatchers.IO) 
    fetchData()
  display(result)
}

Android Kotlin

launch(Dispatchers.Main) {
  val result = withContext(Dispatchers.IO) 
    fetchData()
  display(result)
}

A Missing braces {} around the withContext block causes a syntax error.

B launch must be called with GlobalScope.launch, otherwise it fails.

C fetchData() must be called on the main thread, so this is a runtime error.

D display(result) must be inside withContext block to access result.

💡 Hint

Check how withContext expects its code block syntax.

withContext requires a lambda block enclosed in braces {}. Omitting them causes a syntax error.

🔧 Debug

expert

Why does this withContext code cause a crash?

Analyze this code:

GlobalScope.launch(Dispatchers.IO) {
  val data = fetchData()
  withContext(Dispatchers.Main) {
    updateUI(data)
  }
}

fun updateUI(data: String) {
  textView.text = data
}

Why might this code crash the app?

Android Kotlin

GlobalScope.launch(Dispatchers.IO) {
  val data = fetchData()
  withContext(Dispatchers.Main) {
    updateUI(data)
  }
}

fun updateUI(data: String) {
  textView.text = data
}

A textView is accessed without being on the main thread, causing a crash.

B GlobalScope.launch with Dispatchers.IO does not allow switching to Main dispatcher.

C textView is null or not initialized, causing a NullPointerException.

D fetchData() must be called inside withContext(Dispatchers.Main) to update UI.

💡 Hint

Check if UI elements are properly initialized before use.

The crash is likely due to textView being null or not initialized when updateUI is called, not because of thread switching.