A modern programming language that makes developers happier.

kotlinlang

Untitled

How would I convert this behavior into coroutines?

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

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.

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

```
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.
```

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

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

Although I do agree that `isActive` should be used anyway.

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

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

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

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

&gt; 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