What coroutine scope should I use in this case?

I have a view model where I use viewModelScope and everything works perfect in there. Then, I have a class shared by many view models (injected in the constructor). Inside that class I need to call suspend methods and I don't know what's the correct coroutine scope to use.

Right now I'm using GlobalScope but it doesn't sound quite right, I feel the scope of execution should be guided by the owner of this class instance (the view model). I don't understand why if view model uses viewModelScope this injected class should use GlobalScope if not necessary.

I'm quite new with Kotlin so I might be missing something obvious.

The only scope that can be shared between multiple ViewModels is the Singleton scope, so I assume the class in question is provided as such (otherwise you'd get a new instance for every ViewModel and then it's fine to use the VM scope). What you could do is creating a shared supervisor job, here's how I usually go about that:

@Singleton
open class CoroutinesDispatchers @Inject constructor() {
    open val IO: CoroutineDispatcher = Dispatchers.IO
    open val Main: CoroutineDispatcher = Dispatchers.Main
    open val Default: CoroutineDispatcher = Dispatchers.Default
    open val Unconfined: CoroutineDispatcher = Dispatchers.Unconfined
}

^^ this one allows you to swap out the dispatchers in unit tests and follows the general recommendation not to use Dispatchers.XX directly. The actual scopes are provided as follows:

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class DefaultCoroutineScope
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class UICoroutineScope
@Module
@InstallIn(SingletonComponent::class)
object CoroutinesModule {
    @Provides
    @Singleton
    @DefaultCoroutineScope
    fun defaultCoroutineScope(dispatchers: CoroutinesDispatchers): CoroutineScope = CoroutineScope(
        SupervisorJob() + dispatchers.Default
    )
    @Provides
    @Singleton
    @UICoroutineScope
    fun uiCoroutineScope(dispatchers: CoroutinesDispatchers): CoroutineScope = CoroutineScope(
        SupervisorJob() + dispatchers.Main
    )
}

Then you just inject the scope you need - you could of course use other dispatchers (e.g. IO) or change the dispatcher after launching a coroutine according to your needs. Basically what you get is a kind of a GlobalScope in a more controllable manner.