Android获取网络状态最新方法

3,308 阅读1分钟

class NetWorkUtil {

    private var isAvailable = false
    private val context = APP.getInstance().applicationContext
    private var macAddress: String = ""
    private var ipAddresses: String = ""
    /**
     * 判断是否有网络
     *
     * @return
     */
    fun isNetworkConnected(): Boolean {
        return isAvailable
    }

    fun getMacAddress(): String{
        return macAddress
    }

    fun getIpAddress(): String{
        return ipAddresses
    }

    /**
     * 将ip的整数形式转换成ip形式
     *
     * @param ipInt
     * @return
     */
    private fun int2ip(ipInt: Int): String{
        val sb = StringBuilder()
        sb.append(ipInt and 0xFF).append(".")
        sb.append(ipInt shr 8 and 0xFF).append(".")
        sb.append(ipInt shr 16 and 0xFF).append(".")
        sb.append(ipInt shr 24 and 0xFF)
        return sb.toString()
    }

    private fun convertToMac(mac: ByteArray): String {
        val sb = java.lang.StringBuilder()
        for (i in mac.indices) {
            val b = mac[i]
            var value = 0
            when {
                b in 0..16 -> {
                    value = b.toInt()
                    sb.append("0" + Integer.toHexString(value))
                }
                b > 16 -> {
                    value = b.toInt()
                    sb.append(Integer.toHexString(value))
                }
                else -> {
                    value = 256 + b
                    sb.append(Integer.toHexString(value))
                }
            }
            if (i != mac.size - 1) {
                sb.append(":")
            }
        }
        var str = sb.toString()
        if (str.startsWith("0:")) {
            str= "0$str"
        }
        return str
    }

    init {

        val connectivityManager = context
            .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val request = NetworkRequest.Builder().build()
        connectivityManager.registerNetworkCallback(request,object : ConnectivityManager.NetworkCallback(){
            override fun onBlockedStatusChanged(network: Network, blocked: Boolean) {}


            override fun onCapabilitiesChanged(
                network: Network,
                networkCapabilities: NetworkCapabilities
            ) {
                Log.i(TAG, "net status change! 网络连接改变")
                parseNetworkCapabilities(networkCapabilities)
            }

            override fun onLost(network: Network) {}

            override fun onLinkPropertiesChanged(network: Network, linkProperties: LinkProperties) {}

            override fun onUnavailable() {
                isAvailable = false
            }

            override fun onLosing(network: Network, maxMsToLive: Int) {}

            override fun onAvailable(network: Network) {
                connectivityManager.getNetworkCapabilities(network)?.also {
                    parseNetworkCapabilities(it)
                }
                isAvailable = true
            }
        })
    }

    @SuppressLint("HardwareIds")
    private fun parseNetworkCapabilities(networkCapabilities: NetworkCapabilities){
        var networkType = "eth0"
        // 表明此网络连接成功验证
        if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
            if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
                networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI_AWARE)) {
                // 使用WI-FI
                val wifi = context.applicationContext
                    .getSystemService(Context.WIFI_SERVICE) as WifiManager
                ipAddresses = int2ip(wifi.connectionInfo.ipAddress)
                networkType = "wlan0"

            } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
                || networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)){
                // 使用蜂窝网络
                // 使用有线网络
               networkType = "eth0"
            }
        }
        try {
            val en: Enumeration<NetworkInterface> =
                NetworkInterface.getNetworkInterfaces()
            while (en.hasMoreElements()) {
                val networkInterface: NetworkInterface = en.nextElement()
                if (networkInterface.displayName.toLowerCase(Locale.getDefault()) ==  networkType){
                    val enumeration: Enumeration<InetAddress> = networkInterface.inetAddresses
                    while (enumeration.hasMoreElements()) {
                        val netAddress: InetAddress = enumeration.nextElement()
                        if (!netAddress.isLoopbackAddress && netAddress is Inet4Address) {
                            ipAddresses = netAddress.hostAddress.toString()
                            macAddress = convertToMac(networkInterface.hardwareAddress)
                            break
                        }
                    }
                }

            }
        } catch (ex: SocketException) {
            Log.e(TAG, ex.toString())
        }
    }

    companion object{
        val proxy = NetWorkUtil()
        const val TAG = "NetWorkUtil"
    }
}

在Application中引用NetWorkUtil的实例,其他地方可以通过NetWorkUtil.proxy调用实例方法:

mNetWorkUtil = NetWorkUtil.proxy

if(!NetWorkUtil.proxy.isNetworkConnected()){    
    return
}