Kotlin: Suspended Function Called in Non-Coroutine Context

In modern programming, concurrency has become an essential concept, especially when dealing with operations that need to be executed without blocking the main execution flow. Kotlin, a rapidly growing programming language, provides us with a powerful tool to employ concurrency in our applications through coroutines. A corollary to this feature is the concept of suspended functions, which are central to working with coroutines in Kotlin.

Before diving deep, let’s first understand what suspended functions are. In Kotlin, a suspended function is a function that can be paused and resumed at a later time. This pause-and-resume functionality allows developers to write asynchronous code in a sequential fashion, avoiding the conventional callback approach and making code more readable.

Creating a Suspended Function

To declare a suspended function in Kotlin, you simply use the suspend keyword. For example:

suspend fun fetchDataFromNetwork(): String {
    // Simulating network operation
    delay(1000)
    return "Data fetched from network"
}

In the example above, the function fetchDataFromNetwork is a suspended function, and it simulates a long-running network operation using the delay function.

The Problem: Called in Non-Coroutine Context

A common pitfall when working with suspended functions is calling them outside of a coroutine context. This leads to the infamous error:

java.lang.IllegalStateException: suspend function called in non-coroutine context

This error occurs because suspended functions can only be invoked from within another coroutine or a coroutine builder. Trying to call a suspend function on its own without such a context will throw this exception.

Running Suspend Functions in the Correct Context

To fix this error, you need to ensure that your suspended functions are called from within a coroutine scope. Here are a few ways you can properly call these functions:

Using Coroutine Builders

The easiest way to start a coroutine is by using coroutine builders such as launch or async. These functions are initially started in some scope (like GlobalScope), which provides the necessary coroutine context.

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        val data = fetchDataFromNetwork()
        println(data)
    }
    Thread.sleep(2000) // Wait for the coroutine to finish
}

Note that we used GlobalScope.launch which launches a coroutine without blocking the current thread. This demonstrates calling a suspend function from a suitable coroutine context.

Scoped Coroutines with CoroutineScope

Using CoroutineScope is a more refined and controlled way to manage your coroutines. You define the coroutine context and are responsible for cancelling them manually, which is a preferred approach in large applications or specific environments like Android.

class MyCoroutineScope : CoroutineScope {
    private val job = Job()
    override val coroutineContext = Dispatchers.Main + job

    fun execute() {
        launch {
            val data = fetchDataFromNetwork()
            println(data)
        }
    }

    fun clear() {
        job.cancel()
    }
}

In the above example, MyCoroutineScope class initializes a coroutine scope and provides a launch method for suspended function calls. Also, it includes a clear method that ensures proper cancellation of the coroutine, thus preventing memory leaks.

Conclusion

As Kotlin developers, mastering coroutines and properly utilizing suspended functions improve the efficiency and readability of your code. It is paramount to ensure that all your suspended functions are invoked only within a valid coroutine context to prevent state-related errors. Understanding the builders and the coroutine lifecycle will greatly enhance your concurrent programming skills in Kotlin.