{"id":155,"date":"2026-09-22T10:15:00","date_gmt":"2026-09-22T08:15:00","guid":{"rendered":"https:\/\/grindloop.io\/blog\/?p=155"},"modified":"2026-09-27T00:40:38","modified_gmt":"2026-09-26T22:40:38","slug":"viewmodelscope-async-swallows-api-call","status":"publish","type":"post","link":"https:\/\/grindloop.ai\/blog\/viewmodelscope-async-swallows-api-call\/","title":{"rendered":"Why viewModelScope.async Swallows a Failed API Call"},"content":{"rendered":"

A ProfileViewModel<\/code> loads a profile and logs an analytics event when the screen opens. The analytics call starts failing on a flaky network path. There’s no crash, no log line and no Crashlytics entry. The dashboard just shows the event never fires. What’s wrong?<\/p><\/blockquote>\n\n\n

class ProfileViewModel(\n    private val api: ProfileApi,\n    private val analytics: AnalyticsApi\n) : ViewModel() {\n\n    private val _uiState = MutableStateFlow(ProfileUiState())\n    val uiState: StateFlow<ProfileUiState> = _uiState\n\n    fun loadProfile(userId: String) {\n        viewModelScope.launch {\n            _uiState.update { it.copy(profile = api.getProfile(userId)) }\n        }\n        viewModelScope.async { analytics.logProfileView(userId) } \/\/ fire-and-forget\n    }\n}<\/pre>\n\n\n
This viewModelScope async call is the problem. The analytics work runs in viewModelScope.async<\/code>, and nobody calls await()<\/code> on the result. An async<\/code> started directly on a scope is a root coroutine. Kotlin’s rule for root coroutines is that async<\/code> doesn’t report its exception. It stores it in the returned Deferred<\/code> and waits for someone to call await()<\/code>. Here the Deferred<\/code> is thrown away, so the failure is never seen. A CoroutineExceptionHandler<\/code> wouldn’t help either, since the docs say it has no effect on async<\/code>. And viewModelScope<\/code> runs on a SupervisorJob<\/code>, so the failure doesn’t cancel anything else. The fix is to use launch<\/code> for fire-and-forget work and handle the failure inside it. Keep async<\/code> for work you will await()<\/code>. One detail is easy to miss. Put the same async<\/code> inside a launch<\/code> and the behavior flips. It’s a child then, so its failure propagates and can crash the app.<\/p>\n\n
Why a viewModelScope async call hides the failure<\/h2>\n\n
Kotlin’s coroutine exception-handling guide<\/a> describes two kinds of builders. launch<\/code> propagates exceptions automatically. async<\/code> and produce<\/code> expose them to the caller, who is expected to consume them, for example with await()<\/code>. The guide applies this distinction to root coroutines, meaning ones that aren’t children of another coroutine. It also says a CoroutineExceptionHandler<\/code> has no effect on async<\/code>. The builder catches every exception and puts it in the Deferred<\/code>.<\/p>\n\n
viewModelScope.async { ... }<\/code> creates exactly that kind of root coroutine. Its exception sits in a Deferred<\/code> that no code keeps. Nothing logs it, rethrows it or reports it.<\/p>\n\n
Why nothing else notices<\/h2>\n\n
viewModelScope<\/code> is built on a SupervisorJob<\/code>. Here’s createViewModelScope()<\/code> from CloseableCoroutineScope.kt<\/code><\/a> in androidx-main:<\/p>\n\n\n
internal fun createViewModelScope(): CloseableCoroutineScope {\n    val dispatcher = try {\n        Dispatchers.Main.immediate\n    } catch (_: NotImplementedError) {\n        EmptyCoroutineContext\n    } catch (_: IllegalStateException) {\n        EmptyCoroutineContext\n    }\n    return CloseableCoroutineScope(coroutineContext = dispatcher + SupervisorJob())\n}<\/pre>\n\n\n
The same Kotlin guide says a child’s failure doesn’t propagate to a supervisor job or its other children. So the failed async<\/code> doesn’t cancel the profile load or the scope. With no await, no handler and no cancellation, the failure leaves no trace.<\/p>\n\n
Inside a launch, the same async crashes instead<\/h2>\n\n
It’s a natural follow-up question. Move the fire-and-forget async<\/code> inside a launch<\/code>, and it’s no longer a root coroutine. It’s a child of that launch<\/code>, which runs on a regular Job<\/code>. A failing child cancels its parent, whether or not anyone awaits it. The launch<\/code> then fails. Its exception reaches the scope’s SupervisorJob<\/code>. With no handler installed, it goes to the thread’s uncaught exception handler. On Android, that crashes the app.<\/p>\n\n
This small JVM program rebuilds viewModelScope<\/code> the same way, with a SupervisorJob<\/code> and a single thread named “main.” It installs an uncaught handler that prints instead of exiting. It runs on kotlinx.coroutines 1.9.0.<\/p>\n\n\n
val mainThread = Executors.newSingleThreadExecutor { r -> Thread(r, \"main\") }\n    .asCoroutineDispatcher()\nfun fakeViewModelScope() = CoroutineScope(SupervisorJob() + mainThread)\n\nsuspend fun getProfile(): String { delay(200); return \"profile\" }\nsuspend fun logProfileView() { delay(50); throw IllegalStateException(\"analytics failed\") }\n\nfun main() = runBlocking {\n    Thread.setDefaultUncaughtExceptionHandler { t, e ->\n        println(\"  !! uncaught on '${t.name}': $e  (on Android: process dies)\")\n    }\n\n    println(\"1: unawaited async inside viewModelScope.launch\")\n    val s1 = fakeViewModelScope()\n    val job1 = s1.launch {\n        val profile = async { getProfile() }\n        async { logProfileView() } \/\/ fire-and-forget\n        println(\"  profile = ${profile.await()}\")\n    }\n    job1.join()\n    println(\"  launch cancelled=${job1.isCancelled}, scope active=${s1.isActive}\")\n\n    println(\"2: unawaited async launched directly on the scope (root coroutine)\")\n    val s2 = fakeViewModelScope()\n    s2.async { logProfileView() }\n    delay(300)\n    println(\"  scope active=${s2.isActive} (nothing printed above = silently stored)\")\n\n    mainThread.close()\n}<\/pre>\n\n\n\n
1: unawaited async inside viewModelScope.launch\n  !! uncaught on 'main': java.lang.IllegalStateException: analytics failed  (on Android: process dies)\n  launch cancelled=true, scope active=true\n2: unawaited async launched directly on the scope (root coroutine)\n  scope active=true (nothing printed above = silently stored)<\/pre>\n\n\n
Case 1 is a crash. The profile never prints, because the failing child cancelled the launch<\/code>. Case 2 is the bug in this post. The failure is stored in a Deferred<\/code> and nothing ever reports it.<\/p>\n\n
The fix<\/h2>\n\n\n
fun loadProfile(userId: String) {\n    viewModelScope.launch {\n        _uiState.update { it.copy(profile = api.getProfile(userId)) }\n    }\n    viewModelScope.launch {\n        try {\n            analytics.logProfileView(userId)\n        } catch (e: IOException) {\n            Log.w(\"Analytics\", \"profile view event failed\", e)\n        }\n    }\n}<\/pre>\n\n\n
Fire-and-forget work goes in launch<\/code>, with its failure handled inside. Catch the specific exception you expect, not Exception<\/code>. A broad catch also swallows the CancellationException<\/code> thrown when the ViewModel is cleared.<\/p>\n\n
The rule to remember<\/h2>\n\n
Use async<\/code> only for results you will await()<\/code>. Use launch<\/code> for fire-and-forget work, and handle its failure inside.<\/strong><\/p>\n\n