CheckRealtimeNetwork

NetworkConnection.kt

class NetworkConnection(private val context: Context) : LiveData<Boolean>() {

    private var connectivityManager: ConnectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    private var networkCallback: ConnectivityManager.NetworkCallback? = null

    override fun onActive() {
        super.onActive()
        updateConnection()
        when{
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.N -> {
                connectivityManager.registerDefaultNetworkCallback(connectivityManagerCallback())
            }
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP -> {
                lollipopNetworkRequest()
            }
            else -> {
                context.registerReceiver(networkReceiver, IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION))
            }
        }
    }

    override fun onInactive() {
        super.onInactive()
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
            networkCallback?.let { connectivityManager.unregisterNetworkCallback(it) }
        }else{
            context.unregisterReceiver(networkReceiver)
        }
    }

    private val networkReceiver = object : BroadcastReceiver(){
        override fun onReceive(context: Context?, intent: Intent?) {
            updateConnection()
        }
    }

    private fun updateConnection() {
        val activeNetwork = connectivityManager.activeNetworkInfo
        postValue(activeNetwork?.isConnected == true)
    }

    @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
    private fun lollipopNetworkRequest(){
        val requestBuilder = NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
            .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
        connectivityManager.registerNetworkCallback(requestBuilder.build(), connectivityManagerCallback())
    }

    private fun connectivityManagerCallback() : ConnectivityManager.NetworkCallback{
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
            networkCallback = object : ConnectivityManager.NetworkCallback(){
                override fun onLost(network: Network) {
                    super.onLost(network)
                    postValue(false)
                }

                override fun onAvailable(network: Network) {
                    super.onAvailable(network)
                    postValue(true)
                }
            }
            return networkCallback as ConnectivityManager.NetworkCallback
        }else{
            throw IllegalAccessError("Error")
        }
    }

}



val networkConnection = NetworkConnection(this@MainActivity)
        networkConnection.observe(this@MainActivity, Observer {connect ->
            if(!connect){
                flagConnection = true
                txv_connection.visibility = View.VISIBLE
                txv_connection.text = getString(R.string.label_connection_inactive)
                txv_connection.setBackgroundColor(ContextCompat.getColor(this@MainActivity, R.color.color_red_f2))
            }else if(connect && flagConnection){
                txv_connection.visibility = View.VISIBLE
                txv_connection.text = getString(R.string.label_connection_active)
                txv_connection.setBackgroundColor(ContextCompat.getColor(this@MainActivity, R.color.color_green_02))
                Handler(Looper.getMainLooper()).postDelayed({
                    txv_connection.visibility = View.GONE
                }, 3000)
            }
        })