how do I cancel the children a coroutinescope and not the scope itself?

Put the children in another scope and cancel that

or use

SupervisorJob()

I'm not sure that would work, but I can try.

If parent job is specified, then this supervisor job becomes a child job of its parent and is cancelled when its parent fails or is cancelled. All this supervisor’s children are cancelled in this case, too. The invocation of cancel with exception (other than CancellationException) on this supervisor job also cancels parent.

to be clear,

SupervisorJob()

is for the scope you don't want cancelled

yup, Ive implemented coroutine scope where it needs to. Testing now.

are you calling

cancel()

on the scope itself?

When I need to cancel callback flows in this scope, I'm doing

this.cancel

which is the problem. It's cancelling the scope itself

it sounds like you should be creating another child scope that you cancel, rather than re-using this scope

If I do that, then I would have to recreate the child scope every time I need to activate and deactivate the flow

if you must do it this way, you could always do

this.coroutineContext[Job]!!.children.forEach { it.cancel() }

it seems to me that

CoroutineScope.cancelChildren

should be a thing

Pretty sure

cancelChildren

is indeed a thing.

That is on job and not CoroutineScope

this.coroutineContext.cancelChildren()

should also be possible iirc.

gotcha

Not particularly.

CoroutineScope

!=

Job

. The separation of

CoroutineScope

,

CoroutineContext

and

Job

is a bit.... weird though, but I'm not sure if I could do better myself.

The documentation of coroutinescope directly references the world

children

.

CoroutineScope should be implemented (or used as a field) on entities with a well-defined lifecycle that are responsible for launching children coroutines. Example of such entity on Android is Activity. Usage of this interface may look like this:

To me, that is justification enough itself to include a cancelChildren on this considering the other mechanisms that have children have this functionality.

tbh creating a new child job to put the flows into and then cancelling that sounds more right here to me

Do you mean coroutineScope?

yes, coroutineScope is just creating a Job with the outer scope’s job as parent

yes.

CoroutineScope.cancelChildren

would in effect be syntactic sugar for that. It feels cumbersome to be to necessitate making a singular ephemeral CoroutineScope for this kind of thing.

shrug it seems to be in line with how we have app/session/request “scopes” in other contexts — you’re running some flows to produce something, you put them in a Job so that all complete/get cancelled together

Not every scope has Job, GlobalScope doesn't. It's also true for context, but at least context is more local than Scope