how can i make a background process in jetpack compose?

I'm creating a real-time internet connection check. how can i make a background process in jetpack compose? What would be the best way to do this? I am using the following code:

   val connectionType = mutableStateOf("")

    suspend fun run(context:Context) = withContext(Dispatchers.IO) {
        // Invoking the Connectivity Manager
        val connectivityManager =
            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

        while (true) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                val nw = connectivityManager.activeNetwork
                val actNw = connectivityManager.getNetworkCapabilities(nw)
                if (actNw != null) {
                    when {
                        actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> connectionType.value =
                            "Conexão WIFI"
                        actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> connectionType.value =
                            "Conexão Dados Celular"
                        //for other device how are able to connect with Ethernet
                        actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> connectionType.value =
                            "Conexão Ethernet"
                        //for check internet over Bluetooth
                        actNw.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) -> connectionType.value =
                            "Conexão Bluetooth"
                        else -> connectionType.value = "Sem conexão"

                    }
                } else {
                    connectionType.value = "Sem conexão"
                }
            } else {
                val netInfo = connectivityManager.allNetworkInfo

                for (ni in netInfo) {
                    if (ni.typeName.equals("WIFI", ignoreCase = true))
                        if (ni.isConnected) connectionType.value = "Conexão WIFI"
                    if (ni.typeName.equals("MOBILE", ignoreCase = true))
                        if (ni.isConnected) connectionType.value =
                            "Conexão de Dados Celular"
                        else {
                            connectionType.value = "Sem conexão"
                        }
                }
            }
            delay(1000)
        }
    }

    @Composable
    fun ConnectionChecker() {
        val context = LocalContext.current

        connectionType.value = remember {
            connectionType.value
        }

        LaunchedEffect(Unit) {
            run(context)
        }

    }

It works perfectly but in terms of performance is there a better way?

Let me tell you a better way to check internet connection in jetpack compose

First make NetworkUtility.kt file and paste the below code there. This will return the connection state (Available , UnAvailable).

import android.content.Context
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.produceState
import androidx.compose.ui.platform.LocalContext
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow
val Context.currentConnectivityState: ConnectionState
get() {
val connectivityManager =
getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
return getCurrentConnectivityState(connectivityManager)
}
private fun getCurrentConnectivityState(
connectivityManager: ConnectivityManager
): ConnectionState {
val connected = connectivityManager.allNetworks.any { network ->
connectivityManager.getNetworkCapabilities(network)
?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
?: false
}
return if (connected) ConnectionState.Available else ConnectionState.Unavailable
}
@ExperimentalCoroutinesApi
fun Context.observeConnectivityAsFlow() = callbackFlow {
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val callback = NetworkCallback { connectionState -> trySend(connectionState) }
val networkRequest = NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
.build()
connectivityManager.registerNetworkCallback(networkRequest, callback)
// Set current state
val currentState = getCurrentConnectivityState(connectivityManager)
trySend(currentState)
// Remove callback when not used
awaitClose {
// Remove listeners
connectivityManager.unregisterNetworkCallback(callback)
}
}
fun NetworkCallback(callback: (ConnectionState) -> Unit): ConnectivityManager.NetworkCallback {
return object : ConnectivityManager.NetworkCallback() {
override fun onAvailable(network: Network) {
callback(ConnectionState.Available)
}
override fun onLost(network: Network) {
callback(ConnectionState.Unavailable)
}
}
}
@ExperimentalCoroutinesApi
@Composable
fun connectivityState(): State<ConnectionState> {
val context = LocalContext.current
// Creates a State<ConnectionState> with current connectivity state as initial value
return produceState(initialValue = context.currentConnectivityState) {
// In a coroutine, can make suspend calls
context.observeConnectivityAsFlow().collect { value = it }
}
}
sealed class ConnectionState {
object Available : ConnectionState()
object Unavailable : ConnectionState()
}

Now you have to handle above state in your composable function . Go to your composable function and write the below code there .

 val connection by connectivityState()
val isConnected = connection == ConnectionState.Available

The isConnected variable stores true or false (true means connected with internet and false means not connected)

if (!isConnected) InternetConnection()

if it's not connected with internet just show below msg.

@Composable
fun InternetConnection(modifier: Modifier = Modifier) {
Box(
modifier = modifier
.fillMaxWidth()
.background(redColor), contentAlignment = Center
) {
Text15_500(
text = stringResource(R.string.internet_connection),
modifier = Modifier.padding(top = 10.dp, bottom = 10.dp, start = 10.dp)
)
}
}

Hope it's helpful 👍🏻

This code looks fine only some refactor I can suggest.
connectionType can be declared as this
var connectionType by remember { mutableStateOf("") }

and your run method can be renamed as checkInternetConnection method and place it out of this Activity or Fragment. You can keep it inside some utility, so it provide more re-usability. Please dont pass the context to that, you can create the connectivityManager inside the LaunchedEffect and pass it that function, and get the result as lambda so it looks more readable too.

After refactor your ConnectionChecker will look like this.

@Composable
fun ConnectionChecker() {
var connectionType by remember {
mutableStateOf("")
}
val context = LocalContext.current
LaunchedEffect(Unit) {
val connectivityManager =
context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
checkInternetConnection(connectivityManager) {
connectionType = it
}
}
Text(text = "Hello $connectionType!")
}

and your checkInternetConnection will look like...

suspend fun checkInternetConnection(connectivityManager: ConnectivityManager, updateConnectionType: (String) -> Unit) =
withContext(Dispatchers.IO) {
// Invoking the Connectivity Manager
while (true) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val nw = connectivityManager.activeNetwork
val actNw = connectivityManager.getNetworkCapabilities(nw)
if (actNw != null) {
when {
actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ->
updateConnectionType("Conexão WIFI")
actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) ->
updateConnectionType("Conexão Dados Celular")
// for other device how are able to connect with Ethernet
actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) ->
updateConnectionType("Conexão Ethernet")
// for check internet over Bluetooth
actNw.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) ->
updateConnectionType("Conexão Bluetooth")
else -> updateConnectionType("Sem conexão")
}
} else {
updateConnectionType("Sem conexão")
}
} else {
val netInfo = connectivityManager.allNetworkInfo
for (ni in netInfo) {
if (ni.typeName.equals("WIFI", ignoreCase = true)) {
if (ni.isConnected) updateConnectionType("Conexão WIFI")
}
if (ni.typeName.equals("MOBILE", ignoreCase = true)) {
if (ni.isConnected) updateConnectionType("Conexão de Dados Celular")
else {
updateConnectionType("Sem conexão")
}
}
}
}
delay(1000)
}
}