前言

查了一下判断网络是否可用，发现很多博客给的方法都是不正确的，大部分给的方法都是判断网络是否连接，一般来说，在大多数的情况下确实可以满足需求。但是有时会出现网络连接了却不能用的情况，这时就需要更精准的判断了。网上查到的有效的方法大多都是异步的，后来终于找到了一个不用异步的方法，只支持安卓 23 以上的版本，不过也够用了，已经覆盖 90%的机型了，低于 23 的依然判断是否连接就够用了。

方法列表

  1. isNetworkConnection  :通过socket检查外网的连通性,需要在子线程执行
  2. ping                 :判断是否有外网连接
  3. ping2                :获取当前的网络状态,子线程执行
  4. openSetting          :打开设置界面,requestCode 默认值 RESULT_SETTING
  5. openWiFiSetting      :打开网络设置界面,requestCode 默认值 RESULT_WIFI
  6. isMobile             :判断是否是移动网络
  7. isMobileConnected    :判断是否是移动网络
  8. isWifi               :判断是否是wifi连接
  9. isWifiConnected      :判断是否是wifi连接
  11. getNetworkInfoType   :获得当前的网络信息,返回值 WIFI ,MOBILE
  12. getConnectedType     :获得当前的网络信息,,type = 1 WIFI,type = 0 MOBILE
  13. isNetworkConnected   :判断是否有网络连接,不能判断网络是否可用
  14. isNetworkAvailable   :判断当前网络是否可用,实时
  15. isNetworkAvailableAsync :判断当前网络是否可用，子线程执行

工具类

需要权限，在清单文件中加上：

  1.  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  2.     <uses-permission android:name="android.permission.INTERNET"/>
  1. object NetworkUtils {
  2.     private var s: Socket? = null
  4.     /**
  5.      * 打开 wifi 设置界面 requestCode
  6.      */
  7.     const val RESULT_WIFI = 9999
  9.     /**
  10.      * 打开设置界面 requestCode
  11.      */
  12.     const val RESULT_SETTING = 99999
  14.     /**
  15.      *通过socket检查外网的连通性,需要在子线程执行
  16.      * @param context
  17.      * @return
  18.      */
  19.     fun isNetworkConnection(context: Context): Boolean {
  20.         val connectivityManager =
  21.             context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  22.         val activeNetworkInfo = connectivityManager.activeNetworkInfo
  23.         val connected = null != activeNetworkInfo && activeNetworkInfo.isConnected
  24.         if (!connected) return false
  25.         var routeExists: Boolean
  26.         try {
  27.             if (s == null) {
  28.                 s = Socket()
  29.             }
  30.             val host: InetAddress =
  31.                 InetAddress.getByName("114.114.114.114") //国内使用114.114.114.114，如果全球通用google：8.8.8.8
  32.             s!!.connect(InetSocketAddress(host, 80), 5000) //google:53
  33.             routeExists = true
  34.             s!!.close()
  35.         } catch (e: IOException) {
  36.             routeExists = false
  37.         }
  38.         return connected && routeExists
  39.     }
  42.     /**判断是否有外网连接（普通方法不能判断外网的网络是否连接，比如连接上局域网）
  43.      * 获取当前的网络状态,子线程执行
  44.      * @return
  45.      * @author suncat
  46.      * @category
  47.      */
  48.     fun ping(): Boolean {
  49.         var result: String? = null
  50.         try {
  51.             val ip = "www.baidu.com" // ping 的地址，可以换成任何一种可靠的外网
  52.             val p = Runtime.getRuntime().exec("ping -c 3 -w 100 $ip") // ping网址3次
  53.             // 读取ping的内容，可以不加
  54.             val input: InputStream = p.inputStream
  55.             val `in` = BufferedReader(InputStreamReader(input))
  56.             val sb = StringBuilder()
  57.             var content: String? = ""
  58.             while (`in`.readLine().also { content = it } != null) {
  59.                 sb.append(content)
  60.             }
  61.             // ping的状态
  62.             val status = p.waitFor()
  63.             if (status == 0) {
  64.                 result = "success"
  65.                 return true
  66.             } else {
  67.                 result = "failed"
  68.             }
  69.         } catch (e: IOException) {
  70.             result = "IOException"
  71.         } catch (e: InterruptedException) {
  72.             result = "InterruptedException"
  73.         } finally {
  74.         }
  75.         return false
  76.     }
  78.     /**
  79.      * 获取当前的网络状态,子线程执行
  80.      *   0：当前网络可用
  81.      *  1：需要网页认证的wifi
  82.      *  2：网络不可用的状态
  83.      *  1000：方法错误
  84.      */
  85.     fun ping2(): Int {
  86.         val runtime = Runtime.getRuntime()
  87.         try {
  88.             val p = runtime.exec("ping -c 3 www.baidu.com")
  89.             return p.waitFor()
  90.         } catch (e: Exception) {
  91.             e.printStackTrace()
  92.         }
  93.         return 1
  94.     }
  96.     /**
  97.      * 打开网络设置界面
  98.      */
  99.     fun openWiFiSetting(activity: Activity?, requestCode: Int = RESULT_WIFI) {
  100.         val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
  101.         activity?.startActivityForResult(intent, requestCode)
  102.     }
  104.     /**
  105.      * 打开设置界面
  106.      */
  107.     fun openSetting(activity: Activity?, requestCode: Int = RESULT_SETTING) {
  108.         val intent = Intent(Settings.ACTION_SETTINGS)
  109.         activity?.startActivityForResult(intent, requestCode)
  110.     }
  112.     /**判断是否是移动网络
  113.      * @param context
  114.      * @return
  115.      */
  116.     fun isMobile(context: Context?): Boolean {
  117.         if (context == null) return false
  118.         val connectivity =
  119.             context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  120.         if (connectivity.activeNetworkInfo == null) return false
  121.         return connectivity.activeNetworkInfo.type == ConnectivityManager.TYPE_MOBILE
  122.     }
  124.     /**
  125.      * 判断是否是wifi连接
  126.      */
  127.     fun isWifi(context: Context?): Boolean {
  128.         if (context == null) return false
  129.         val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  130.         if (cm.activeNetworkInfo == null) return false
  131.         return cm.activeNetworkInfo.type == ConnectivityManager.TYPE_WIFI
  132.     }
  135.     /**
  136.      * 判断MOBILE网络是否连接
  137.      *
  138.      * @param context
  139.      * @return
  140.      */
  141.     fun isMobileConnected(context: Context?): Boolean {
  142.         if (context != null) {
  143.             val mConnectivityManager = context
  144.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  145.             val mMobileNetworkInfo =
  146.                 mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
  147.             if (mMobileNetworkInfo != null) {
  148.                 return mMobileNetworkInfo.isAvailable
  149.             }
  150.         }
  151.         return false
  152.     }
  154.     /**
  155.      * 判断WIFI网络是否连接
  156.      *
  157.      * @param context
  158.      * @return
  159.      */
  160.     fun isWifiConnected(context: Context?): Boolean {
  161.         if (context != null) {
  162.             val mConnectivityManager =
  163.                 context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  164.             val mWiFiNetworkInfo =
  165.                 mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
  166.             if (mWiFiNetworkInfo != null) {
  167.                 return mWiFiNetworkInfo.isAvailable
  168.             }
  169.         }
  170.         return false
  171.     }
  173.     /**
  174.      *获得当前的网络信息,返回值 WIFI ,MOBILE
  175.      * @param context
  176.      * @return
  177.      */
  178.     fun getNetworkInfoType(context: Context): String? {
  179.         val connectivityManager =
  180.             context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  181.         val activeNetworkInfo = connectivityManager.activeNetworkInfo
  182.         if (activeNetworkInfo != null) {
  183.             if (activeNetworkInfo.isConnected) {
  184.                 //获得当前的网络信息
  185.                 return activeNetworkInfo.typeName
  186.             }
  187.         }
  188.         return null
  189.     }
  191.     /**
  192.      * 获取当前网络连接的类型信息,type = 1 WIFI,type = 0 MOBILE
  193.      *
  194.      * @param context
  195.      * @return
  196.      */
  197.     fun getConnectedType(context: Context?): Int {
  198.         if (context != null) {
  199.             val mConnectivityManager = context
  200.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  201.             val mNetworkInfo = mConnectivityManager.activeNetworkInfo
  202.             if (mNetworkInfo != null && mNetworkInfo.isAvailable) {
  203.                 return mNetworkInfo.type
  204.             }
  205.         }
  206.         return -1
  207.     }
  210.     /**
  211.      * 判断是否有网络连接,不能判断网络是否可用
  212.      *
  213.      * @param context
  214.      * @return
  215.      */
  216.     fun isNetworkConnected(context: Context?): Boolean {
  217.         if (context != null) {
  218.             val mConnectivityManager = context
  219.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  220.             val mNetworkInfo = mConnectivityManager.activeNetworkInfo
  221.             if (mNetworkInfo != null) {
  222.                 return mNetworkInfo.isAvailable
  223.             }
  224.         }
  225.         return false
  226.     }
  228.     /**
  229.      * 判断当前网络是否可用,实时
  230.      * @param context
  231.      * @return
  232.      */
  233.     fun isNetworkAvailable(context: Context?): Boolean {
  234.         if (context == null) return false
  235.         var isNetUsable = false
  236.         val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  237.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  238.             val networkCapabilities = manager.getNetworkCapabilities(manager.activeNetwork)
  239.             if (networkCapabilities != null) {
  240.                 isNetUsable =
  241.                     networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
  242.             }
  243.         } else {
  244.             isNetUsable = isNetworkConnected(context)
  245.         }
  246.         return isNetUsable
  247.     }
  249.     /**
  250.      * 判断当前网络是否可用，子线程执行
  251.      * @param context
  252.      * @return
  253.      */
  254.     fun isNetworkAvailableAsync(context: Context?): Boolean {
  255.         val isConnected = isNetworkConnected(context)
  256.         return if (isConnected) {
  257.             ping()
  258.         } else {
  259.             false
  260.         }
  261.     }
  263. }

参考

判断当前网络是否可用两种方法