A modern programming language that makes developers happier.

kotlinlang

Sans titre

Hi. I'm relatively new to Coroutines. Is it okey to use `GlobalScope.launch { }` to run an infinite while to draw on canvas (Android SurfaceView) or it is a better solution ?

UI has a lifecycle (activities, fragments, etc)

Ok, so I must run the coroutine attached to the lifecycle of the view.

so if you use global scope, your coroutine will continue to run when the view or activity is destroyed

Ok, and stop running only when the app is destroyed, is that ?

for example, if it were activity:

```
lateinit var onCreateScope: CoroutineScope
fun onCreate(){
  onCreateScope = CoroutineScope(Dispatchers.Main)  
}

fun onDestroy() {
  onCreateScope.cancel()
}
```

I found an exemple code (<https://github.com/elye/demo_android_surfaceview_vs_view/blob/7ffb8481788b2b1eadd0da58536b92db1293f229/app/src/main/java/com/elyeproj/surfaceviewexplore/SlowSurfaceView.kt#L39>) and it's seems that it's for an old version of couroutines,  without notion of scopes

So I don't need a `job` propertie and I can directly call `surfaceViewScope.cancel()` in `surfaceDestroyed()`, if I'm right :slightly_smiling_face:

that’s what is awesome about scopes :slightly_smiling_face:

you define lifecycle (the scoping) first, then you can launch coroutines!

It's still a bit unatural to have to define it explicitly, but I understand the concept, thanks for the help !

Lot of time, if you use LifeCycle librabry, I think you can attached coroutine to the lifecycleowner

Because my needed was to have a background worker for the `SurfaceView`, I was been able to define directly my propertie on declaration with `private val surfaceViewScope = CoroutineScope(Dispatchers.Default)`, I guess it's right :grimacing:

just make sure you switch to the main thread for main specific code

Like it, must spend more time on Coroutines

also, realize that `Dispatchers.Default` is a thread pool, so if you launch more than one coroutine you lose thread safety (any code confined to a single coroutine is thread safe, even if it runs across multiple threads)

yes, but the `IO` dispatcher is for blocking calls that don’t do any work while they block a thread