class Client {
    sealed interface State {
        object Loading: State
        object Success: State
        object Error: State
    }

    interface MyCallListener {
        suspend fun onResult(result: State)
    }

    var methodListener: MyCallListener? = null

    suspend inline fun call(): SharedFlow<State> {

        val flow = MutableSharedFlow<State>()

        //onResult is called elsewhere. this way, it's possible to emit a result to the flow
        methodListener = object : MyCallListener {
            override suspend fun onResult(result: State) {
                flow.emit(result)
            }
        }

        flow.tryEmit(State.Loading)

        CoroutineScope(coroutineContext).launch {
            var latestValue: State? = null
            launch {
                flow.collect {
                    latestValue = it
                }
            }
            delay(5000)
            if (latestValue is State.Loading) {
                flow.emit(State.Error)
            }
        }

        return flow
    }
}

class MyUseCase(
    val client: Client
) {
    suspend fun foo() = client.call()
}

CoroutineScope(coroutineContext)

CoroutineScope