NetworkConnectivityFlow.kt

import android.content.Context
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow

interface ConnectivityObserver {
    fun observe(): Flow<Status>

    enum class Status {
        Available, Unavailable, NotObservedYet
    }
}
class NetworkConnectivityObserver(
    context: Context
): ConnectivityObserver {
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    private val availableNetworks: MutableSet<Network> = HashSet()

    override fun observe(): Flow<ConnectivityObserver.Status> = callbackFlow<ConnectivityObserver.Status> {
        val networkStatusCallback = object : ConnectivityManager.NetworkCallback() {

            override fun onAvailable(network: Network) {
                availableNetworks.add(network)
                trySend(ConnectivityObserver.Status.Available)
            }

            override fun onLost(network: Network) {
                availableNetworks.remove(network)
                if (availableNetworks.size == 0) {
                    trySend(ConnectivityObserver.Status.Unavailable)
                }
            }
        }

        val request = NetworkRequest.Builder()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .build()
        connectivityManager.registerNetworkCallback(request, networkStatusCallback)

        if (connectivityManager.activeNetwork == null) {
            trySend(ConnectivityObserver.Status.Unavailable)
        }
        awaitClose {
            connectivityManager.unregisterNetworkCallback(networkStatusCallback)
        }
    }
}