net connect state observer

NetStateObserver

package zyc.android.utils

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.ConnectivityManager.CONNECTIVITY_ACTION
import android.net.Network
import android.os.Build
import android.util.Log
import androidx.lifecycle.*


/**
 * NetworkMonitor 用来监控网络是否连接，兼容 api-29，目前仅支持context主体的对象调用（根据context接口注册网络回调）
 * Author: zyc
 * Date  : 2020/4/8.
 */
@Suppress("unused", "ImplicitThis", "ConstantConditionIf")
object NetConnectStateObserver : MutableLiveData<Boolean>() {
    private const val LOG_DEBUG = false
    private var connectionStateReceiver: BroadcastReceiver? = null
    private var networkCallback: ConnectivityManager.NetworkCallback? = null

    override fun observe(owner: LifecycleOwner, observer: Observer<in Boolean>) {
        super.observe(owner, observer)

        if (LOG_DEBUG) {
            Log.d(
                "networkMonitor",
                "NetworkMonitor.observe api-level: ${Build.VERSION.SDK_INT} curr-state: ${owner.lifecycle.currentState}"
            )
        }

        if (owner is Context) {
            registerMonitor(owner)
        } else {
            throw IllegalArgumentException("owner must be a sub class of context")
        }

        owner.lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                if (source.lifecycle.currentState == Lifecycle.State.DESTROYED) {
                    if (LOG_DEBUG) {
                        Log.d(
                            "networkMonitor",
                            "NetworkMonitor.onStateChanged: ${source.javaClass.simpleName} event: $event, unregister monitor"
                        )
                    }

                    owner.lifecycle.removeObserver(this)
                    unregisterMonitor(owner)
                }
            }
        })
    }

    @Suppress("DEPRECATION")
    fun registerMonitor(context: Context) {
        val connectManager = context.getConnectivityManager()
        if (Build.VERSION.SDK_INT >= 29) {
            networkCallback = object : ConnectivityManager.NetworkCallback() {
                override fun onLost(network: Network) {
                    postValue(false)
                }

                override fun onAvailable(network: Network) {
                    postValue(true)
                }
            }
            networkCallback?.apply { connectManager.registerDefaultNetworkCallback(this) }
        } else {
            connectionStateReceiver = object : BroadcastReceiver() {
                override fun onReceive(context: Context?, intent: Intent?) {
                    val networkInfo = connectManager.activeNetworkInfo
                    postValue(networkInfo?.isConnected ?: false)
                }
            }
            context.registerReceiver(connectionStateReceiver, IntentFilter(CONNECTIVITY_ACTION))
        }
    }

    fun unregisterMonitor(context: Context) {
        if (Build.VERSION.SDK_INT >= 29) {
            networkCallback?.apply {
                context.getConnectivityManager().unregisterNetworkCallback(this)
            }
        } else {
            connectionStateReceiver?.apply {
                context.unregisterReceiver(this)
            }
        }
    }
}


fun Context.getConnectivityManager() =
    getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager