Lifecycle-aware Internet Network Detector

NetworkConnectionListener.kt

package com.your.package

import android.content.Context
import androidx.lifecycle.MutableLiveData


class NetworkConnectionListener constructor(context: Context) :
    MutableLiveData<NetworkState>() {

    private val connectionMonitor = NetworkDetector.getInstance(context.applicationContext)

    override fun onActive() {
        super.onActive()
        connectionMonitor.startDetecting(::setConnected)
    }

    override fun onInactive() {
        connectionMonitor.stopDetecting()
        super.onInactive()
    }

    private fun setConnected(isConnected: Boolean) =
        postValue(if (isConnected) NetworkState.Connected else NetworkState.Disconnected)
}

NetworkDetector.kt

package com.your.package

import android.annotation.TargetApi
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.Network
import android.os.Build

internal sealed class NetworkDetector(
    protected val connectivityManager: ConnectivityManager
) {

    protected var listener: ((Boolean) -> Unit) = {}

    abstract fun startDetecting(callback: (Boolean) -> Unit)
    abstract fun stopDetecting()


    companion object {
        fun getInstance(context: Context): NetworkUtils {
            val connectivityManager =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                MarshmallowConnectivityManager(connectivityManager)
            } else {
                LegacyConnectivityManager(context, connectivityManager)
            }
        }

    }

    
    private class MarshmallowConnectivityManager(connectivityManager: ConnectivityManager) :
        NetworkUtils(connectivityManager) {

        private val networkCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network) {
                super.onAvailable(network)
                listener(true)
            }

            override fun onLost(network: Network) {
                super.onLost(network)
                listener(false)
            }
        }

        override fun startDetecting(callback: (Boolean) -> Unit) {
            listener = callback
            connectivityManager.registerDefaultNetworkCallback(networkCallback)
        }

        override fun stopDetecting() {
            connectivityManager.unregisterNetworkCallback(networkCallback)
            listener = {}
        }
    }

    @Suppress("Deprecation")
    private class LegacyConnectivityManager(
        private val context: Context,
        connectivityManager: ConnectivityManager
    ) : NetworkUtils(connectivityManager) {

        private val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)

        private val isNetworkConnected: Boolean
            get() = connectivityManager.activeNetworkInfo?.isConnected == true

        override fun startDetecting(callback: (Boolean) -> Unit) {
            listener = callback
            listener(isNetworkConnected)
            context.registerReceiver(receiver, filter)
        }

        override fun stopDetecting() {
            context.unregisterReceiver(receiver)
            listener = {}
        }

        private val receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                listener(isNetworkConnected)
            }
        }
    }

}

NetworkState.kt

enum class NetworkState {
    Connected,
    Disconnected
}