A modern programming language that makes developers happier.

kotlinlang

Is this the correct way to attach a new `Job` to the parent context?
```val connectionJob = Job(viewModelScope.coroutineContext.job)```

Depends what you're trying to achieve. Creating a custom `Job` isn't something you should need to do much, and it's very easy to get wrong. What's stopping you from just making a job with `launch`?

Yes, but it can only make sense in a very specific cases. The more convenient is to just
`val connectionJob = viewModelScope.launch { }`

So in case I need two `launch`, nest them inside?

So tie the knot like this?

```                        lateinit var connectionJob: Job
                        connectionJob = viewModelScope.launch {
                            launch {
                                connection.state.collect {
                                    bluetoothConnectionState.value = it
                                    when (it?.state) {
                                        GattConnectionState.STATE_DISCONNECTED -> {
                                            connectionJob.cancel()
                                        }

                                        else -> {}
                                    }
                                }
                            }
                            launch {
                                connection.networkState.collect {
                                    networkingStateFlow.value = it
                                }
                            }
                        }```

Inside the outer job, you need to leave out the `viewModelScope` part. The `launch` block creates its own scope, and you want your inner jobs to be children of that scope, instead of the outer scope.

Sorry, slack ain't very good at properly indenting code, and I'm not sure how to left-align it in the editor window :confused:

Typically it's
• Highlight the code you want to indent,
• Press Shift+Tab several times.

Nope, doesn't work, as the `connectionJob` isn't properly wired in, gotta go with the `Job`

`connectionJob`'s parent is certainly `viewModelScope`'s job when you create it using `viewModelScope.launch {}`.

`connectionJob` will be `null` inside though, so that's not gonna work out too well

Do you only want to use `connectionJob` inside the `launch`?

```viewModelScope.launch {
    val connectionScope = this
    launch {
        connection.state.collect {
            bluetoothConnectionState.value = it
            when (it?.state) {
                GattConnectionState.STATE_DISCONNECTED -&gt; {
                    connectionScope.cancel()
                }

                else -&gt; {}
            }
        }
    }
    launch {
        connection.networkState.collect {
            networkingStateFlow.value = it
        }
    }
}```

Time to rework my code to remove a bunch of `Job()` usages ^^