How would I convert this behavior into coroutines?

# coroutines

[Ive Vasiljevic]

How would I convert this behavior into coroutines?

Untitled

[Dominaezzz]

GlobalScope.launch(Dispatchers.Main) {
    delay(1500)
    currentSpeedText.text = "${speedService.acquireSpeed().roundToNDecimalPlaces(1)} km/h"
}

[Ive Vasiljevic]

Why GlobalScope and not CoroutineScope?

[Dominaezzz]

You can (and should) use a more specific scope, like some activity scope or view model scope but without context of where this code is going to run GlobalScope is most accurate.

[Dominaezzz]

The behaviour is the same anyway.

[Ive Vasiljevic]

How would I run this coroutine indefinitely over and over again?

[Ive Vasiljevic]

Until I say it to stop

[Ive Vasiljevic]

similar to handler.removeCallbacks()

[streetsofboston]

val job = scope.launch(Dispatchers.Main) {
    while (true) {
        delay(1500)
        currentSpeedText.text = "${speedService.acquireSpeed().roundToNDecimalPlaces(1)} km/h"
    }
}

...

// either this
job.cancel() // cancels the `launch` only
// or this
scope.cancel() // cancels the `launch` and the ends the scope.

[reline]

@streetsofboston I believe you should be using while (isActive) instead of while (true) here or your job will continue even after being cancelled.

[streetsofboston]

The call to delay will throw a CancelationException when job.cancel() (or scope.cancel()) is called and your Coroutine ends properly.

[Dominaezzz]

Since delay is used, it's fine.

[reline]

ah 🤦‍♂️

[Dominaezzz]

Although I do agree that isActive should be used anyway.

[streetsofboston]

If you have long-running blocking code (not suspending code), then calling ensureActive() or isActive (here and there) is a good way to go.

[Dominaezzz]

ensureActive() and isActive is not really available in non-suspending code.

[Dominaezzz]

Unless you actually mean blocking, then cancellation simply isn't possible.

[gildor]

isActive is not suspend, so it’s not a problem to use it in non-suspending code

[gildor]

actually mean blocking, then cancellation simply isn’t possible

It’s possible if you can split this blocking invocation to multiple steps, like when you read/write to stream, when. So it really depends on nature of this blocking operation, sometimes you just have some cancellation handle even for blocking operation