A modern programming language that makes developers happier.

kotlinlang

Is there anyway to know if a Job has been cancelled other than checking `isActive` or having a CancellationException thrown?

A callback? Maybe I need to think more in coroutines. Bascially I want to subscribe to an Observable and keep the subscription until the Job is cancelled - after which is dispose.

you can call `join()`, which will suspend until the job completes or fails

right now I have a:
```
try {
delay(MAX_LONG)
} finally {
dispose()
}
```

but yea for that use case you probably want `invokeOnCompletion`

but depending on where the Observable comes from, there is well-tested adaptor libraries

<https://github.com/Kotlin/kotlinx.coroutines/blob/master/reactive/README.md>

I didn’t find anything in the kotlinx-reactive one

Best i found was <https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-rx2/kotlinx.coroutines.rx2/io.reactivex.-observable-source/open-subscription.html>

But that does not appear to clean up correctly

It’s a Supervisor Job associated with a View

just turn it into a Flow and collect it from a coroutine that is a child of that job

`openSubscription` should work if you use `consumeEach`, but it is deprecated

`collect { }` will cancel correctly if its coroutine is cancelled

and that will dispose the rx subscription

Thanks  - Flow just didn’t feel like the right use-case here. The stream is not really lazy, but this will work.

and I believe `asFlow()` is stable as of coroutines 1.3.2

Oh I’m a couple versions behind :upside_down_face:

Lazy or not, Flow is basically the official coroutines-friendly analogue to Rx now, so it’s probably the right use case.

I think you need to convert the Observable to Flowable first correct;/

I think you need to convert the Observable to a Flowable first correct?