devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android网络状态变化监听 -- 结合registerNetworkCallback和广播(kotlin)_android监听网络状态变化

作者：AllinToyou | 2024-03-19 05:30:02

赞

踩

android监听网络状态变化

如图

218416259a5147a4971f27e6518401e7.png

 

 

说明
  AndroidAndroid针对网络状态变化的监听，在应用内我们通用需要监听设备网络状态的变化，作出相应的业务处理，需要一个方便的、全局的监听实现。。
  针对不同设备的系统版本，使用不同的API方法实现；
  注意使用广播监听网络状态在高版本的适配问题；

  1、Build.VERSION.SDK_INT >= Build.VERSION_CODES.N，使用connectivityManager.registerDefaultNetworkCallback()方法；
  2、Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP，使用connectivityManager.registerNetworkCallback(networkRequest, new MyNetworkCallback());方法；
  3、其它系统版本使用广播监听；
  4、NetworkListenerHelper可以添加多个页面的监听，当某个页面需要监听网络时，就可以添加到监听者集合中，页面关闭时移除这个监听者，也可以使用事件总线；

核心实现

NetworkListenerHelper

  1. package com.let.networkstatusmonitor
  2.  
  3. import android.annotation.SuppressLint
  4. import android.content.Context
  5. import android.content.IntentFilter
  6. import android.net.ConnectivityManager
  7. import android.net.ConnectivityManager.NetworkCallback
  8. import android.net.Network
  9. import android.net.NetworkCapabilities
  10. import android.net.NetworkRequest
  11. import android.os.Build
  12. import com.let.networkstatusmonitor.NetworkBroadcastReceiver.NetworkBroadcastCallback
  13. import com.let.networkstatusmonitor.NetworkUtils.getNetWorkState
  14. import java.util.concurrent.CopyOnWriteArrayList
  15.  
  16. /**
  17.  * @Author: let
  18.  * @date: 2022/11/15 17:29
  19.  * @description: 网络状态变化的监听类，根据android不同版本的系统，有 [ConnectivityManager.registerNetworkCallback]和注册广播两种实现方式；
  20.  */
  21. object NetworkListenerHelper {
  22.     private val TAG = "NetworkListenerHelper"
  23.     private var mContext: Context? = null
  24.  
  25.     @Volatile
  26.     private var mListenerList: CopyOnWriteArrayList<NetworkConnectedListener>? = null
  27.  
  28.     /**
  29.      * 注册网络状态的监听；
  30.      */
  31.     @SuppressLint("MissingPermission")
  32.     fun registerNetworkListener() {
  33.         when {
  34.             Build.VERSION.SDK_INT >= Build.VERSION_CODES.N -> {
  35.                 val connectivityManager =
  36.                     mContext!!.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  37.                 if (connectivityManager == null) {
  38.                     LogUtils.el(
  39.                         TAG,
  40.                         "registerNetworkListener#return#connectivityManager=$connectivityManager"
  41.                     )
  42.                     return
  43.                 }
  44.                 connectivityManager.registerDefaultNetworkCallback(MyNetworkCallback())
  45.             }
  46.             Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP -> {
  47.                 val connectivityManager = mContext
  48.                     .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  49.                 if (connectivityManager == null) {
  50.                     LogUtils.el(
  51.                         TAG,
  52.                         "registerNetworkListener#return#connectivityManager=$connectivityManager"
  53.                     )
  54.                     return
  55.                 }
  56.                 val builder: NetworkRequest.Builder
  57.                 builder = NetworkRequest.Builder()
  58.                 builder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
  59.                     .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
  60.                 val networkRequest = builder.build()
  61.                 connectivityManager.registerNetworkCallback(networkRequest, MyNetworkCallback())
  62.             }
  63.             else -> {
  64.                 // 通过广播的方式监听网络；
  65.                 val mNetworkBroadcastReceiver = NetworkBroadcastReceiver()
  66.                 val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
  67.                 mContext!!.registerReceiver(mNetworkBroadcastReceiver, filter)
  68.                 mNetworkBroadcastReceiver.setBroadcastCallback(object : NetworkBroadcastCallback {
  69.                     override fun onNetworkBroadcastCallback(
  70.                         isConnected: Boolean,
  71.                         networkStatus: NetworkStatus?
  72.                     ) {
  73.                         //
  74.                         notifyAllListeners(isConnected, networkStatus!!)
  75.                     }
  76.                 })
  77.             }
  78.         }
  79.     }
  80.  
  81.     /**
  82.      * 通知所有接收者；
  83.      *
  84.      * @param isConnected
  85.      * @param networkStatus
  86.      */
  87.     private fun notifyAllListeners(
  88.         isConnected: Boolean,
  89.         networkStatus: NetworkStatus
  90.     ) {
  91.         if (CollectionUtils.isNotEmpty(mListenerList)) {
  92. //            mListenerList.stream().forEach(networkConnectedListener -> {
  93. //                networkConnectedListener.onNetworkConnected(isConnected, networdStatus);
  94. //            });
  95.             for (listener in mListenerList!!) {
  96.                 listener?.onNetworkConnected(isConnected, networkStatus)
  97.             }
  98.         }
  99.     }
  100.  
  101.     /**
  102.      * 添加回调的监听者；
  103.      */
  104.     @Synchronized
  105.     fun addListener(listener: NetworkConnectedListener?) {
  106.         if (listener == null) {
  107.             return
  108.         }
  109.         if (mListenerList == null) {
  110.             mListenerList = CopyOnWriteArrayList()
  111.         }
  112.         // 防止重复添加；
  113.         if (!mListenerList!!.contains(listener)) {
  114.             mListenerList!!.add(listener)
  115.         }
  116.     }
  117.  
  118.     /**
  119.      * 移除某个回调实例；
  120.      *
  121.      * @param listener
  122.      */
  123.     @Synchronized
  124.     fun removeListener(listener: NetworkConnectedListener?) {
  125.         if (listener != null && CollectionUtils.isNotEmpty(mListenerList)) {
  126.             mListenerList!!.remove(listener)
  127.         }
  128.     }
  129.  
  130.     fun unregisterNetworkCallback() {
  131.         if (mContext == null) {
  132.             return
  133.         }
  134.         val connectivityManager = mContext
  135.             .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  136.         if (connectivityManager == null) {
  137.             LogUtils.el(
  138.                 TAG,
  139.                 "registerNetworkListener#return#connectivityManager=$connectivityManager"
  140.             )
  141.             return
  142.         }
  143.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  144.             connectivityManager.unregisterNetworkCallback(NetworkCallback())
  145.         }
  146.     }
  147.  
  148.     interface NetworkConnectedListener {
  149.         /**
  150.          * @param isConnected
  151.          * @param networkStatus
  152.          */
  153.         fun onNetworkConnected(
  154.             isConnected: Boolean,
  155.             networkStatus: NetworkStatus?
  156.         )
  157.     }
  158.  
  159.     @SuppressLint("NewApi") My
  160.     private class MyNetworkCallback : NetworkCallback() {
  161.         //当用户与网络连接（或断开连接）（可以是WiFi或蜂窝网络）时，这两个功能均作为默认回调;
  162.         override fun onAvailable(network: Network) {
  163.             super.onAvailable(network)
  164.             LogUtils.d(TAG, "onAvailable#network=$network")
  165.             // 需要同步获取一次网络状态；
  166.             val netWorkState = getNetWorkState(mContext!!)
  167.             LogUtils.d(TAG, "onAvailable#netWorkState=$netWorkState")
  168.             //
  169.             notifyAllListeners(true, netWorkState)
  170.         }
  171.  
  172.         override fun onLost(network: Network) {
  173.             super.onLost(network)
  174.             LogUtils.d(TAG, "onLost#network=$network")
  175.             // 需要同步获取一次网络状态；
  176.             val netWorkState = getNetWorkState(mContext!!)
  177.             LogUtils.d(TAG, "onLost#netWorkState=$netWorkState")
  178.             //
  179.             notifyAllListeners(false, netWorkState)
  180.         }
  181.  
  182.         override fun onCapabilitiesChanged(
  183.             network: Network,
  184.             networkCapabilities: NetworkCapabilities
  185.         ) {
  186.             super.onCapabilitiesChanged(network, networkCapabilities)
  187.             LogUtils.d(TAG, "onCapabilitiesChanged#network=$network")
  188.             //            LogUtils.d(TAG, "onCapabilitiesChanged#network=" + network + ", networkCapabilities=" + networkCapabilities);
  189.             // 表示能够和互联网通信（这个为true表示能够上网）
  190.             if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
  191.                 when {
  192.                     networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
  193.                         LogUtils.d(TAG, "onCapabilitiesChanged#网络类型为wifi")
  194.                     }
  195.                     networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> {
  196.                         LogUtils.d(TAG, "onCapabilitiesChanged#蜂窝网络")
  197.                     }
  198.                     else -> {
  199.                         LogUtils.d(TAG, "onCapabilitiesChanged#其他网络")
  200.                     }
  201.                 }
  202.             }
  203.         }
  204.     }
  205.  
  206.     fun init(context: Context): NetworkListenerHelper {
  207.         mContext = context
  208.         return this
  209.     }
  210. }

MainActivity

  1. package com.let.networkstatusmonitor
  2.  
  3. import android.os.Bundle
  4. import android.widget.TextView
  5. import androidx.appcompat.app.AppCompatActivity
  6. import com.let.networkstatusmonitor.NetworkListenerHelper.NetworkConnectedListener
  7.  
  8. /**
  9.  * @Author: let
  10.  * @date: 2021/11/15 17:29
  11.  * @description:
  12.  */
  13. class MainActivity : AppCompatActivity(), NetworkConnectedListener {
  14.     private val TAG = "MainActivity"
  15.     private var mTvResult: TextView? = null
  16.     override fun onCreate(savedInstanceState: Bundle?) {
  17.         super.onCreate(savedInstanceState)
  18.         setContentView(R.layout.activity_main)
  19.         mTvResult = findViewById(R.id.tv_result)
  20.  
  21.         // 网络状态回调；
  22.         NetworkListenerHelper.addListener(this@MainActivity)
  23.     }
  24.  
  25.  
  26.     override fun onDestroy() {
  27.         super.onDestroy()
  28.         NetworkListenerHelper.removeListener(this@MainActivity)
  29.     }
  30.  
  31.     override fun onNetworkConnected(isConnected: Boolean, networkStatus: NetworkStatus?) {
  32.         LogUtils.d(TAG, "onNetworkConnected#isConnected=$isConnected")
  33.         val trim = mTvResult!!.text.toString()
  34.         val status = networkStatus.status
  35.         val desc = networkStatus.desc
  36.         mTvResult!!.post { mTvResult!!.text = "\n网络变化通知：status=$status, desc=$desc\n$trim" }
  37.     }
  38. }

NetworkStatus

  1. package com.let.networkstatusmonitor;
  2.  
  3. /**
  4.  * @Author: let
  5.  * @date: 2022/11/15 17:30
  6.  * @description: 网络连接状态的枚举
  7.  */
  8. public enum NetworkStatus {
  9.  
  10.     /**
  11.      * ；
  12.      */
  13.     NONE(-1, "无网络连接"),
  14.     /**
  15.      * 解析数据内容失败
  16.      */
  17.     MOBILE(0, "移动网络连接"),
  18.     /**
  19.      * 网络问题
  20.      */
  21.     WIFI(1, "WIFI连接");
  22.  
  23.     private int status;
  24.     private String desc;
  25.  
  26.     NetworkStatus(int code, String msg) {
  27.         this.status = code;
  28.         this.desc = msg;
  29.     }
  30.  
  31.     public int getStatus() {
  32.         return status;
  33.     }
  34.  
  35.     public String getDesc() {
  36.         return desc;
  37.     }
  38.  
  39.     @Override
  40.     public String toString() {
  41.         return "NetwordStatus{" +
  42.                 "status=" + status +
  43.                 ", desc='" + desc + '\'' +
  44.                 "} " + super.toString();
  45.     }
  46. }

NetworkUtils

  1. package com.let.networkstatusmonitor
  2.  
  3. import android.annotation.SuppressLint
  4. import android.content.Context
  5. import android.net.ConnectivityManager
  6. import android.net.NetworkCapabilities
  7. import android.os.Build
  8.  
  9. /**
  10.  * @Author: let
  11.  * @date: 2022/11/15 17:31
  12.  * @description:
  13.  */
  14. object NetworkUtils {
  15.     @JvmStatic
  16.     @SuppressLint("MissingPermission")
  17.     fun getNetWorkState(context: Context): NetworkStatus {
  18.         return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
  19.             val connectivityManager =
  20.                 context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  21.             val mobileNetInfo =
  22.                 connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
  23.             val wifiNetInfo =
  24.                 connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
  25.             if (mobileNetInfo != null && mobileNetInfo.isAvailable) {
  26.                 //WIFI和移动网络均未连接
  27.                 NetworkStatus.MOBILE
  28.             } else if (wifiNetInfo != null && wifiNetInfo.isAvailable) {
  29.                 //WIFI和移动网络均未连接
  30.                 NetworkStatus.WIFI
  31.             } else {
  32.                 NetworkStatus.NONE
  33.             }
  34.         } else {
  35.             when {
  36.                 isMobileConnected(context) -> {
  37.                     NetworkStatus.MOBILE
  38.                 }
  39.                 isWifiConnected(context) -> {
  40.                     NetworkStatus.WIFI
  41.                 }
  42.                 else -> {
  43.                     NetworkStatus.NONE
  44.                 }
  45.             }
  46.         }
  47.  
  48. //            //获取所有网络连接的信息
  49. //            Network[] networks = connMgr.getAllNetworks();
  50. //            //通过循环将网络信息逐个取出来
  51. //            for (int i = 0; i < networks.length; i++) {
  52. //                //获取ConnectivityManager对象对应的NetworkInfo对象
  53. //                NetworkInfo networkInfo = connMgr.getNetworkInfo(networks[i]);
  54. //                if (networkInfo.isConnected()) {
  55. //                    if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
  56. //                        return NetwordStatus.WIFI;
  57. //                    } else if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
  58. //                        return NetwordStatus.MOBILE;
  59. //                    }
  60. //                }
  61. //            }
  62.     }
  63.  
  64.     /**
  65.      * 判断网络是否连接
  66.      *
  67.      * @param context
  68.      * @return
  69.      */
  70.     @SuppressLint("MissingPermission")
  71.     fun isOnline(context: Context?): Boolean {
  72.         if (context == null) {
  73.             return false
  74.         }
  75.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
  76.             val connMgr =
  77.                 context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  78.             val networkInfo = connMgr.activeNetworkInfo
  79.             return networkInfo != null && networkInfo.isAvailable
  80.         } else {
  81.             val connectivityManager = context
  82.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  83.             val activeNetwork = connectivityManager.activeNetwork ?: return false
  84.             val networkCapabilities =
  85.                 connectivityManager.getNetworkCapabilities(activeNetwork)
  86.             if (networkCapabilities != null) {
  87.                 return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
  88.             }
  89.         }
  90.         return false
  91.     }
  92.  
  93.     @SuppressLint("MissingPermission")
  94.     fun isWifiConnected(context: Context?): Boolean {
  95.         if (context == null) {
  96.             return false
  97.         }
  98.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
  99.             val connectivityManager = context
  100.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  101.             val networkInfo = connectivityManager
  102.                 .getNetworkInfo(ConnectivityManager.TYPE_WIFI)
  103.             if (networkInfo != null) {
  104.                 return networkInfo.isAvailable
  105.             }
  106.         } else {
  107.             val connectivityManager = context
  108.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  109.             val activeNetwork = connectivityManager.activeNetwork ?: return false
  110.             val networkCapabilities =
  111.                 connectivityManager.getNetworkCapabilities(activeNetwork)
  112.             if (networkCapabilities != null) {
  113.                 return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
  114.             }
  115.         }
  116.         return false
  117.     }
  118.  
  119.     @SuppressLint("MissingPermission")
  120.     fun isMobileConnected(context: Context?): Boolean {
  121.         if (context == null) {
  122.             return false
  123.         }
  124.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
  125.             val connectivityManager = context
  126.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  127.             val networkInfo = connectivityManager
  128.                 .getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
  129.             if (networkInfo != null) {
  130.                 return networkInfo.isAvailable
  131.             }
  132.         } else {
  133.             val connectivityManager = context
  134.                 .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
  135.             val activeNetwork = connectivityManager.activeNetwork ?: return false
  136.             val networkCapabilities =
  137.                 connectivityManager.getNetworkCapabilities(activeNetwork)
  138.             if (networkCapabilities != null) {
  139.                 return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
  140.             }
  141.         }
  142.         return false
  143.     }
  144. }
NetworkBroadcastReceiver
  1. package com.let.networkstatusmonitor
  2.  
  3. import android.content.BroadcastReceiver
  4. import android.content.Context
  5. import android.content.Intent
  6. import android.net.ConnectivityManager
  7. import android.text.TextUtils
  8.  
  9. /**
  10.  * @Author: let
  11.  * @date: 2021/11/15 17:28
  12.  * @description: 网络状态的监听广播
  13.  */
  14. class NetworkBroadcastReceiver : BroadcastReceiver() {
  15.     private val TAG = "NetworkBroadcastReceiver"
  16.     private var mBroadcastCallback: NetworkBroadcastCallback? = null
  17.     override fun onReceive(context: Context, intent: Intent) {
  18.         if (intent.action == null) {
  19.             LogUtils.el(TAG, "onReceive#intent=$intent")
  20.             return
  21.         }
  22.         val action = intent.action
  23.         LogUtils.d(TAG, "onReceive#action=$action")
  24.         if (TextUtils.equals(intent.action, ConnectivityManager.CONNECTIVITY_ACTION)) {
  25.             // 申请权限；
  26. //        if (!XXPermissions.isGrantedPermission(context, Permission.WRITE_EXTacERNAL_STORAGE,
  27. //                Permission.READ_EXTERNAL_STORAGE)) {
  28. //        }
  29. //        NetworkInfo mobNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
  30. //        NetworkInfo wifiNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
  31. //        if (!mobNetInfo.isConnected() && !wifiNetInfo.isConnected()) {
  32. //            //WIFI和移动网络均未连接
  33. //            netContentListener.netContent(false);
  34. //        } else {
  35. //            //WIFI连接或者移动网络连接
  36. //            netContentListener.netContent(true);
  37. //        }
  38.             val isOnline = NetworkUtils.isOnline(context)
  39.             val networkStatus = NetworkUtils.getNetWorkState(context)
  40.             LogUtils.d(TAG, "onReceive#isOnline=$isOnline, networdStatus=$networkStatus")
  41.             if (mBroadcastCallback != null) {
  42.                 mBroadcastCallback!!.onNetworkBroadcastCallback(isOnline, networkStatus)
  43.             }
  44.         }
  45.     }
  46.  
  47.     fun setBroadcastCallback(broadcastCallback: NetworkBroadcastCallback?) {
  48.         mBroadcastCallback = broadcastCallback
  49.     }
  50.  
  51.     interface NetworkBroadcastCallback {
  52.         /**
  53.          * 根据监听的结果返回连接状态和网络状态；
  54.          *
  55.          * @param isConnected
  56.          * @param networkStatus
  57.          */
  58.         fun onNetworkBroadcastCallback(
  59.             isConnected: Boolean,
  60.             networkStatus: NetworkStatus?
  61.         )
  62.     }
  63. }

ApplicationSupporter

  1. package com.let.networkstatusmonitor
  2.  
  3. import android.app.Application
  4.  
  5. /**
  6.  * @Author: let
  7.  * @date: 2022/11/15 17:28
  8.  * @description:
  9.  */
  10. class ApplicationSupporter : Application() {
  11.     private val TAG = "ApplicationSupporter"
  12.     override fun onCreate() {
  13.         super.onCreate()
  14.         instance = this
  15.         BaseApplicationHelper.getInstance()
  16.             .initApplicationContext(this)
  17.         // 注册网络状态监听；
  18.         NetworkListenerHelper.init(this).registerNetworkListener()
  19.     }
  20.  
  21.     companion object {
  22.         var instance: ApplicationSupporter? = null
  23.     }
  24. }

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/267004
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号