Ok, I think I got it,

coroutineScope

doesn't return until it completes... but then, I'd need to pass the CoroutineScope in

download(scope: CoroutineScope)

? That's a bit messy... and I can't even use a receiver since it's declared on another object... (unless I use

with

... 😒)

Yes, that's the problem. Was just going to write it 🙂

Declare

CoroutineScope.download()

instead

You should write functions that start a coroutine like this:

fun CoroutineScope.download() =

.

But I call it like this:

client.download(url, it.sink, it.range).consumeEach { currBytes ->
						val currTotal = totalDownloaded.addAndGet(currBytes)
						i { "progress: $currTotal" }
						progress.send(DownloadProgress.Downloading(currTotal, totalExpectedPartsSize))
					}

Since

client

is the dependency where it's declared...

Or you could simply use

GlobalScope.produce

. I think it is okay in this case, since you use

consumeEach

, the producer will anyway be cancelled if the consumer is cancelled or failed.

Oh.. that's why all the ReceiveChannel operators are defined with

GlobalScope

? I guess it'll take a bit of time to get used to structured concurrency... but it's probably worth it 🙂

Maybe you could pass

client

as a normal parameter?

download(client, ....).consumeEach { ... } }

download

is defined on

client

...

Wait, why does

Client

not implement

CoroutineScope

?

Because it's not my outer scope... I need the downloading to be cancelled if my outer scope (an Android IntentService) is cancelled... @nulldev

You could also do it the other way around by the way,

client.download(scope, ....)

. Having the scope as the receiver is just a convention.

True, but then passing it in the constructor is probably much cleaner, because it's not something that changes every call I make to

download

... like I said, it comes out nicer in functional programming 🙂... but I think they should have some examples in the official docs that are not functional oriented...