Hello guys, could you please tell me why exactly in examples

Job

was added to the

coroutineContext

override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

?

So that you can get hold of the

Job

and cancel it when necessary

Could you please give me an example where use this job? If I write

launch

or

async

it will attach to the

scope

so then I will write

override fun onDestroy() {
        super.onDestroy()
        coroutineContext.cancelChildren()
    }

In case you use a ViewModel, your

job

will be a

SupervisorJob

. In the ViewModels’ onClear, you’d call the

cancel

method on that

private val job = SupervisorJob()

So with

+job

we can specify in which

Job

will be linked

launch

or

async

?

Yep, this will be the parent/top

job

from that point on

I see, and otherwise if I didn't specify some job it will be just

Job()

by default, right?

Yes, I think it’ll default to a plain Job().

got it, thank you!

This will allow you to not only cancel, but join on it or anything else you’d like to do with the

job

. It’s a pattern 🙂

could you please give me some examples of usages. I understand why we need

SupervisorJob

to avoid stop parent coroutines by children crash. but why we need a job above. we stop all jobs by

coroutineContext.cancelChildren()

and if we want pause some specific job we save it instance from

launch

and then stop it. but what is best practise for this parent job?

If it is a top-level/top-parent Job, then

cancelChildren

suffices. But if your coroutine-scope and its context participates in structured concurrency, the calling context may need all its children to finish before it continues of finishes. That would mean

cancelChildren

is not enough, you’d need to call

cancel

to cancel your top-job.

oh, I see, thank you a lot for your patience and answers.

Of course. Glad to help!

Thank you, will read!

get() = Dispatchers.Main + job

Instead of this idiom you also can consider ready to user

MainScope()

class CoBaseViewModel : ViewModel(), CoroutineScope by MainScope()

it uses SupervisorJob by default and Main thread dispatcher One more thing: keeping reference on job or use

coroutineContext

to cancel job is not necessary, there is

CoroutineScope.cancel()

extension function, so for ViewModel you can just do this:

override fun onCleared() {
    super.onCleared()
    cancel()
}

We tend to stay away from using MainScope and inject the Dispatcher instead to make it easier to test (inject Dispatchers.Main and for tests inject Dispatchers.Unconfined).

You can set Main dispatcher in tests, no need to inject it

@gildor Please check Avoid usage of global scope https://proandroiddev.com/kotlin-coroutines-patterns-anti-patterns-f9d12984c68e#4fb8

Check what?

Checked, you are rock 🙂

😁

got it. thank you. main scope is the same that I wrote above but in much nice way

MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)

and in my example was

private val job = SupervisorJob()

    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job

yes, this is what I meant, also you can use delegation

We still inject it, not only the Main, but the IO (and Default) are injected as well. :-)

Usually I prefer to avoid IO injection, instead make all API that use IO or Default testable without dispatcher switch (this approach doesn’t work with Main, because you cannot use Main dispatcher in unit tests)