android 监听网络状态的变化及实战

青旅半醒 2022-07-15 04:29 615阅读 0赞

### **本篇文章已授权微信公众号 guolin\_blog （郭霖）独家发布** ###

**[转载请注明博客地址：][Link 1]http://blog.csdn.net/gdutxiaoxu/article/details/53008266**

平时我们在请求错误的情况下，通常会进行处理一下，一般来说，主要分为两方面的错误

*  没有网络的错误
 *  在有网络的情况下，我们客户端的错误或者服务器端的错误

**今天这篇博客主要阐述以下问题**

*  怎样监听网络状态的变化，包括是否打开WiFi，否打开数据网络，当前连接的网络是否可用
 *  网络没有打开情况下的处理,如弹出对话框，跳转到 打开 WiFi设置的界面等
 *  非WiFi情况下是否加载图片，是否播放视频等

**Android 技术人，希望让你看到程序猿不同的一面，除了分享 Coding，，还有职场心得，面试经验，学习心得，人生感悟等等。希望通过该公众号，我们不只会敲代码，我们还会。。。。。。**

![Android 技术人][Android]

## 实现思路 ##

在网络错误的情况下获取网络状态进行判断，这种方法是可行的，但你想过了没有，如果每次都要进行这样的判断，岂不是代码量很多？有人会说，那把代码封装到一个类不就好了吗？这样确实能减少代码量，但是每次都要主动去获取，这样是不是挺麻烦的。实际上，google 早就帮我们封装好了，在网络状态变化的情况下会发出广播，我们只需要监听广播就好了 。

### 使用静态广播还是动态注册广播的方式好呢？ ###

如果你不太清楚的话，我只能说即 基础不扎实。我们的应用之所以要监听网络状态的 变化，主要是为了在错误的情况下方便进行处理，退出我们当前的应用之后当然不需要监听了，所以选择动态注册广播。

*  动态注册：随着所在的Activity或者应用销毁 以后，不会受到该广播
 *  静态注册：退出应用后，仍然能够收到相应的广播

共同点：都需要在AndroidMainest清单文件里面注册

## 通过广播监听网络状态的两种方法 ##

### 静态注册 ###

### 动态注册 ###

第一步：在AndroidMainest文件里面注册

第二步：调用 Context registerReceiver(Receiver,IntentFilter) 进行注册

IntentFilter filter = new IntentFilter();
    filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
    filter.addAction("android.net.wifi.WIFI_STATE_CHANGED");
    filter.addAction("android.net.wifi.STATE_CHANGE");
    registerReceiver(mNetworkChangeListener,filter);

### 我们自定义的NetworkChangeListener广播 ###

/** * 网络改变监控广播 * <p> * 监听网络的改变状态,只有在用户操作网络连接开关(wifi,mobile)的时候接受广播, * 然后对相应的界面进行相应的操作，并将 状态 保存在我们的APP里面 * <p> * <p> * Created by xujun */
    public class NetworkConnectChangedReceiver extends BroadcastReceiver { 
    
        private static final String TAG = "xujun";
        public static final String TAG1 = "xxx";
    
        @Override
        public void onReceive(Context context, Intent intent) { 
            // 这个监听wifi的打开与关闭，与wifi的连接无关
            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) { 
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                Log.e(TAG1, "wifiState" + wifiState);
                switch (wifiState) { 
                    case WifiManager.WIFI_STATE_DISABLED:
                        APP.getInstance().setEnablaWifi(false);
                        break;
                    case WifiManager.WIFI_STATE_DISABLING:
    
                        break;
                    case WifiManager.WIFI_STATE_ENABLING:
                        break;
                    case WifiManager.WIFI_STATE_ENABLED:
                        APP.getInstance().setEnablaWifi(true);
                        break;
                    case WifiManager.WIFI_STATE_UNKNOWN:
                        break;
                    default:
                        break;
    
    
                }
            }
            // 这个监听wifi的连接状态即是否连上了一个有效无线路由，当上边广播的状态是WifiManager
            // .WIFI_STATE_DISABLING，和WIFI_STATE_DISABLED的时候，根本不会接到这个广播。
            // 在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播，
            // 当然刚打开wifi肯定还没有连接到有效的无线
            if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) { 
                Parcelable parcelableExtra = intent
                        .getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (null != parcelableExtra) { 
                    NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                    State state = networkInfo.getState();
                    boolean isConnected = state == State.CONNECTED;// 当然，这边可以更精确的确定状态
                    Log.e(TAG1, "isConnected" + isConnected);
                    if (isConnected) { 
                        APP.getInstance().setWifi(true);
                    } else { 
                        APP.getInstance().setWifi(false);
                    }
                }
            }
            // 这个监听网络连接的设置，包括wifi和移动数据的打开和关闭。.
            // 最好用的还是这个监听。wifi如果打开，关闭，以及连接上可用的连接都会接到监听。见log
            // 这个广播的最大弊端是比上边两个广播的反应要慢，如果只是要监听wifi，我觉得还是用上边两个配合比较合适
            if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) { 
                ConnectivityManager manager = (ConnectivityManager) context
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                Log.i(TAG1, "CONNECTIVITY_ACTION");
    
                NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
                if (activeNetwork != null) {  // connected to the internet
                    if (activeNetwork.isConnected()) { 
                        if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) { 
                            // connected to wifi
                            APP.getInstance().setWifi(true);
                            Log.e(TAG, "当前WiFi连接可用 ");
                        } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) { 
                            // connected to the mobile provider's data plan
                            APP.getInstance().setMobile(true);
                            Log.e(TAG, "当前移动网络连接可用 ");
                        }
                    } else { 
                        Log.e(TAG, "当前没有网络连接，请确保你已经打开网络 ");
                    }
    
    
                    Log.e(TAG1, "info.getTypeName()" + activeNetwork.getTypeName());
                    Log.e(TAG1, "getSubtypeName()" + activeNetwork.getSubtypeName());
                    Log.e(TAG1, "getState()" + activeNetwork.getState());
                    Log.e(TAG1, "getDetailedState()"
                            + activeNetwork.getDetailedState().name());
                    Log.e(TAG1, "getDetailedState()" + activeNetwork.getExtraInfo());
                    Log.e(TAG1, "getType()" + activeNetwork.getType());
                } else {    // not connected to the internet
                    Log.e(TAG, "当前没有网络连接，请确保你已经打开网络 ");
                    APP.getInstance().setWifi(false);
                    APP.getInstance().setMobile(false);
                    APP.getInstance().setConnected(false);
    
                }
    
    
            }
        }
    
    
    }

最后，别忘记添加一下权限

<uses-permission android:name="android.permission.INTERNET"/>
     
     
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
    
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

### 思路解析 ###

从上面的代码中，我们可以知道我们将我们当前的网络状态保存在我们的 APP 里面，这样当网络状态变化的时候会自动去改变 APP 里面相应的状态量，我们进行网络处理的 时候只需要去获取 APP里面的状态量，便可以判断出是属于哪一种网络错误，是不是很方便呢。

至于广播的Action主要有三种类型：

**WifiManager.WIFI\_STATE\_CHANGED\_ACTION**

这个监听wifi的打开与关闭，与wifi的连接无关

**WifiManager.NETWORK\_STATE\_CHANGED\_ACTION：**

这个监听wifi的连接状态即是否连上了一个有效无线路由，当上边广播的状态是WifiManager.WIFI\_STATE\_DISABLING，和WIFI\_STATE\_DISABLED的时候，根本不会接到这个广播。

在上边广播接到广播是WifiManager.WIFI\_STATE\_ENABLED状态的同时也会接到这个广播，当然刚打开wifi肯定还没有连接到有效的无线

**ConnectivityManager.CONNECTIVITY\_ACTION**

这个监听网络连接的设置，包括wifi和移动数据的打开和关闭。.  
最好用的还是这个监听。wifi如果打开，关闭，以及连接上可用的连接都会接到监听。这个广播的最大弊端是比上边两个广播的反应要慢，如果只是要监听wifi，我觉得还是用上边两个配合比较合适。

至于这个ConnectivityManager，NetworkInfo是什么东西，别急，下面会大概介绍一下。

--------------------

## ConnectivityManager和NetworkInfo ##

### ConnectivityManager主要用来干什么 ###

*  Monitor network connections (Wi-Fi, GPRS, UMTS, etc.) （用来处理网络连接 ，包括Wi-Fi, GPRS, UMTS等）
 *  Send broadcast intents when network connectivity changes（用 网络状态发生变化的时候发出 广播 ）
 *  Attempt to “fail over” to another network when connectivity to a network is lost（但断开网络连接的时候，尝试去；连接另外一个网络
 *  Provide an API that allows applications to query the coarse-grained or fine-grained state of the available networks（
 *  Provide an API that allows applications to request and select networks for their data traffic

### 怎样获取ConnectivityManager对象呢？ ###

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context
            .CONNECTIVITY_SERVICE);

### 获取 NetworkInfo对象 ###

主要有一下 几种方法

*  getNetworkInfo(int networkType)，但是这个方法已经过时，官网的解释如下：This method was deprecated in API level 23. This method does not support multiple connected networks of the same type. Use getAllNetworks() and getNetworkInfo(android.net.Network) instead.
 *  getNetworkInfo(Network network)
 *  getActiveNetwork()  
    Returns a Network object corresponding to the currently active default data network.
 *  getActiveNetworkInfo()，Returns details about the currently active default data network.
 *  getAllNetworkInfo()这个方法已经过时，Use getAllNetworks() and getNetworkInfo(android.net.Network) instead.

**综上所述，我们如果要知道当前Mobile网络或者WiFi网络是否已经连接上，总共有两种方法。**

第一种方法，只不过在 API23的时候已经 过时了

State wifiState = null;
    State mobileState = null;
    
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context
            .CONNECTIVITY_SERVICE);
    wifiState = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();
    mobileState = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();
    
    Log.d(TAG1,
            "wifi状态:" + wifiState + "\n mobile状态:" + mobileState);
    
    if (wifiState != null && mobileState != null
            && State.CONNECTED != wifiState
            && State.CONNECTED == mobileState) { // 手机网络连接成功 
        Log.d(TAG1, "手机2g/3g/4g网络连接成功");
    
        APP.getInstance().setMobile(true);
        APP.getInstance().setWifi(false);
        APP.getInstance().setConnected(true);
    
    } else if (wifiState != null && State.CONNECTED == wifiState) { // 无线网络连接成功 
        Log.d(TAG1, "无线网络连接成功");
    
        APP.getInstance().setMobile(false);
        APP.getInstance().setWifi(true);
        APP.getInstance().setConnected(true);
    
    } else if (wifiState != null && mobileState != null
            && State.CONNECTED != wifiState
            && State.CONNECTED != mobileState) { // 手机没有任何的网络 
        Log.d(TAG1, "手机没有任何的网络");
    
        APP.getInstance().setMobile(false);
        APP.getInstance().setWifi(false);
        APP.getInstance().setConnected(false);
    
    }

第二种方法

ConnectivityManager manager = (ConnectivityManager) context
            .getSystemService(Context.CONNECTIVITY_SERVICE);
    Log.i(TAG1, "CONNECTIVITY_ACTION");
    
    NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
    if (activeNetwork != null) {  // connected to the internet
        if (activeNetwork.isConnected()) { 
            if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) { 
                // connected to wifi
                APP.getInstance().setWifi(true);
                Log.e(TAG, "当前WiFi连接可用 ");
            } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) { 
                // connected to the mobile provider's data plan
                APP.getInstance().setMobile(true);
                Log.e(TAG, "当前移动网络连接可用 ");
            }
        } else { 
            Log.e(TAG, "当前没有网络连接，请确保你已经打开网络 ");
        }
    } else {    // not connected to the internet
        Log.e(TAG, "当前没有网络连接，请确保你已经打开网络 ");
        APP.getInstance().setWifi(false);
        APP.getInstance().setMobile(false);
        APP.getInstance().setConnected(false);
    
    }

--------------------

## 网络错误情况的处理 ##

正如前面所提到的，这篇博客吧网络错误主要分为两大类

*  没有网络情况的错误
 *  在有网络的情况下，我们客户端的错误或者服务器端的错误  
    在这里 我们主要处理没有网络情况下的错误，现在 个人了解到 的主要有两种处理方法。

第一种做法：  
在APP启动的 时候检查当前是否已经连接上网络，弹出一个对话框没有的话跳转到设置界面或者WiFi设置界面或者打开移动网络界面 。

第二种方法

其实跟第一种做法差不多，只是在每一次 错误的情况下，都会判断当前有没有 网络 ，没有弹出一个对话框，跳转到设置界面或者WiFi设置界面或者打开移动网络界面 ， 下面我们我们一起来看一下 怎样弹出一个对话框，并且跳转到相应的设置界面

这里我们采取第一种做法，效果图如下

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-soHQMd4i-1617723276312)(https://raw.githubusercontent.com/gdutxiaoxu/blog\_pic/master/19\_05/9fe4afa0gw1f9dp8oqfc2g208u0gjh6x.gif)\]

### 代码如下 ###

public static void showWifiDlg(final Context context) { 
        AlertDialog.Builder builder = new AlertDialog.Builder(context.getApplicationContext());
        if (mWifiDialog == null) { 
            mWifiDialog = builder.setIcon(R.drawable.ic_launcher)         //
                    .setTitle("wifi设置")            //
                    .setMessage("当前无网络").setPositiveButton("设置", new DialogInterface
                            .OnClickListener() { 
    
                        @Override
                        public void onClick(DialogInterface dialog, int which) { 
                            // 跳转到系统的网络设置界面
                            Intent intent = null;
                            // 先判断当前系统版本
                            if (android.os.Build.VERSION.SDK_INT > 10) {   // 3.0以上
                                intent = new Intent(android.provider.Settings
                                        .ACTION_WIFI_SETTINGS);
                            } else { 
                                intent = new Intent();
                                intent.setClassName("com.android.settings",
                                        Settings.ACTION_WIFI_SETTINGS);
                            }
                            if ((context instanceof Application)) { 
                                intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
                            }
                            context.startActivity(intent);
    
                        }
                    }).setNegativeButton("知道了", null).create();
            // 设置为系统的Dialog，这样使用Application的时候不会 报错
            mWifiDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
        }
        mWifiDialog.show();
    
    
    }

这里对几个 重要的 Action说一下

*  ACTION\_DATA\_ROAMING\_SETTINGS ： 跳转到移动网络设置界面
 *  ACTION\_WIFI\_SETTINGS  
    Activity Action: Show settings to allow configuration of Wi-Fi.
 *  ACTION\_WIRELESS\_SETTINGS  
    Activity Action: Show settings to allow configuration of wireless controls such as Wi-Fi, Bluetooth and Mobile networks.

关于更多Activity Action，请参考[官网地址][Link 2]

**需要注意的是**

若我们 使用的Context不是Activity 的Context 而是Application的 Context，我们 需要做以下处理 ，否则会报错

// 设置为系统级别的Dialog
    mWifiDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
    
    if ((context instanceof Application)) {                             intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
     }
    context.startActivity(intent);
    
    
    在AndroidMainFest中添加以下权限 。
     
        <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

--------------------

## 智能无图 ##

智能无图，这种浏览模式我们平时 很常见，比如在UC浏览器中，网易新闻中都有看到这种模式，这种模式的实质就是监听网络状态，再根据是否是WiFi去确定是否加载网络图片。

### 效果图如下 ###

我们可以看到在开启智能无图的情况下，若不是连接WiFi ，我们是不会去加载网络图片的。

![3c63abb06c7a8b97cb86d3028be006c3.gif][]

### 实现的核心代码如下 ###

1）当智能无图模式变化的时候，我们会把标志存进SharePreferences中

mSwitchWifiPic.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { 
        @Override
        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 
        
            SPUtils.put(SPConstants.isIntelligentNoPic,isChecked);
            
        }
    });

同时我们为了进来的时候界面与SharePreferences中的 isIntelligentNoPic的值保持一致，我们需要调用一下代码

boolean isIntelligentNoPic = SPUtils.getBoolean(SPConstants.isIntelligentNoPic);
    mSwitchWifiPic.setChecked(isIntelligentNoPic);

2）在NewsListAdapter中

// 是否开启智能无图模式，true表示开启智能无图模式
    boolean isIntelligentNoPic = SPUtils.getBoolean(Constants.SPConstants.isIntelligentNoPic);
    WriteLogUtil.i("isIntelligentNoPic=" + isIntelligentNoPic);
    if (isIntelligentNoPic) { 
        if (APP.getInstance().isWifi()) { 
            GlideUtils.display(mContext, iv, picUrl);
        } else { 
            iv.setImageDrawable(new ColorDrawable(Color.GRAY));
        }
    
    } else { 
        GlideUtils.display(mContext, iv, picUrl);
    }

至于APP.getInstance().isWifi()表示当前是否连接WiFi，是通过 监听广播实现的 ，前面已经说明了，这里就不再阐述了。

--------------------

## 拓展工具类 ##

以下工具类参考[Android获取网络状态][Android 1]

public class NetStateUtils { 
    
        /** * 判断当前网络是否是移动网络 * * @param context * @return boolean */
        public static boolean is3G(Context context) { 
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetInfo != null
                    && activeNetInfo.getType() == ConnectivityManager.TYPE_MOBILE) { 
                return true;
            }
            return false;
        }
    
        /** * 判断当前网络是否是wifi网络 * * @param context * @return boolean */
        public static boolean isWifi(Context context) { 
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetInfo != null
                    && activeNetInfo.getType() == ConnectivityManager.TYPE_WIFI) { 
                return true;
            }
            return false;
        }
    
        /** * 判断当前网络是否是2G网络 * * @param context * @return boolean */
        public static boolean is2G(Context context) { 
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetInfo != null
                    && (activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_EDGE
                    || activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_GPRS || activeNetInfo
                    .getSubtype() == TelephonyManager.NETWORK_TYPE_CDMA)) { 
                return true;
            }
            return false;
        }
    
        /** * wifi是否打开 */
        public static boolean isWifiEnabled(Context context) { 
            ConnectivityManager mgrConn = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            TelephonyManager mgrTel = (TelephonyManager) context
                    .getSystemService(Context.TELEPHONY_SERVICE);
            return ((mgrConn.getActiveNetworkInfo() != null && mgrConn
                    .getActiveNetworkInfo().getState() == NetworkInfo.State.CONNECTED) || mgrTel
                    .getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS);
        }
    
        /** * 判断是否有网络连接 * * @param context * @return */
        public static boolean isNetworkConnected(Context context) { 
            if (context != null) { 
                // 获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
                ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                        .CONNECTIVITY_SERVICE);
                // 获取NetworkInfo对象
                NetworkInfo networkInfo = manager.getActiveNetworkInfo();
                //判断NetworkInfo对象是否为空
                if (networkInfo != null)
                    return networkInfo.isAvailable();
            }
            return false;
        }
    
        /** * 判断MOBILE网络是否可用 * * @param context * @param context * @return */
        public static boolean isMobileConnected(Context context) { 
            if (context != null) { 
                //获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
                ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                        .CONNECTIVITY_SERVICE);
                //获取NetworkInfo对象
                NetworkInfo networkInfo = manager.getActiveNetworkInfo();
                //判断NetworkInfo对象是否为空 并且类型是否为MOBILE
                if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE)
                    return networkInfo.isAvailable();
            }
            return false;
        }
    
        /** * 获取当前网络连接的类型信息 * 原生 * * @param context * @return */
        public static int getConnectedType(Context context) { 
            if (context != null) { 
                //获取手机所有连接管理对象
                ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                        .CONNECTIVITY_SERVICE);
                //获取NetworkInfo对象
                NetworkInfo networkInfo = manager.getActiveNetworkInfo();
                if (networkInfo != null && networkInfo.isAvailable()) { 
                    //返回NetworkInfo的类型
                    return networkInfo.getType();
                }
            }
            return -1;
        }
    
        /** * 获取当前的网络状态 ：没有网络-0：WIFI网络1：4G网络-4：3G网络-3：2G网络-2 * 自定义 * * @param context * @return */
        public static int getAPNType(Context context) { 
            //结果返回值
            int netType = 0;
            //获取手机所有连接管理对象
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            //获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            //NetworkInfo对象为空 则代表没有网络
            if (networkInfo == null) { 
                return netType;
            }
            //否则 NetworkInfo对象不为空 则获取该networkInfo的类型
            int nType = networkInfo.getType();
            if (nType == ConnectivityManager.TYPE_WIFI) { 
                //WIFI
                netType = 1;
            } else if (nType == ConnectivityManager.TYPE_MOBILE) { 
                int nSubType = networkInfo.getSubtype();
                TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService
                        (Context.TELEPHONY_SERVICE);
                //3G 联通的3G为UMTS或HSDPA 电信的3G为EVDO
                if (nSubType == TelephonyManager.NETWORK_TYPE_LTE
                        && !telephonyManager.isNetworkRoaming()) { 
                    netType = 4;
                } else if (nSubType == TelephonyManager.NETWORK_TYPE_UMTS
                        || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
                        || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
                        && !telephonyManager.isNetworkRoaming()) { 
                    netType = 3;
                    //2G 移动和联通的2G为GPRS或EGDE，电信的2G为CDMA
                } else if (nSubType == TelephonyManager.NETWORK_TYPE_GPRS
                        || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
                        || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
                        && !telephonyManager.isNetworkRoaming()) { 
                    netType = 2;
                } else { 
                    netType = 2;
                }
            }
            return netType;
        }
    
        /** * 判断GPS是否打开 * ACCESS_FINE_LOCATION权限 * * @param context * @return */
        public static boolean isGPSEnabled(Context context) { 
            //获取手机所有连接LOCATION_SERVICE对象
            LocationManager locationManager = ((LocationManager) context.getSystemService(Context
                    .LOCATION_SERVICE));
            return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        }
    
        /** * 获得本机ip地址 * * @return */
        public static String GetHostIp() { 
            try { 
                for (Enumeration<NetworkInterface> en = NetworkInterface
                        .getNetworkInterfaces(); en.hasMoreElements(); ) { 
                    NetworkInterface intf = en.nextElement();
                    for (Enumeration<InetAddress> ipAddr = intf.getInetAddresses(); ipAddr
                            .hasMoreElements(); ) { 
                        InetAddress inetAddress = ipAddr.nextElement();
                        if (!inetAddress.isLoopbackAddress()) { 
                            return inetAddress.getHostAddress();
                        }
                    }
                }
            } catch (SocketException ex) { 
            } catch (Exception e) { 
            }
            return null;
        }
    
        /** * 获取本机串号imei * * @param context * @return */
        public static String getIMEI(Context context) { 
            TelephonyManager telephonyManager = (TelephonyManager) context
                    .getSystemService(Context.TELEPHONY_SERVICE);
            return telephonyManager.getDeviceId();
        }
    
        /*** * 判断是否有外网连接（普通方法不能判断外网的网络是否连接，比如连接上局域网） * * @return */
    
        public static final boolean ping() { 
    
            String result = null;
            try { 
                String ip = "www.baidu.com";// ping 的地址，可以换成任何一种可靠的外网
                Process p = Runtime.getRuntime().exec("ping -c 3 -w 100 " + ip);// ping网址3次
                // 读取ping的内容，可以不加
                InputStream input = p.getInputStream();
                BufferedReader in = new BufferedReader(new InputStreamReader(input));
                StringBuffer stringBuffer = new StringBuffer();
                String content = "";
                while ((content = in.readLine()) != null) { 
                    stringBuffer.append(content);
                }
                Log.d("------ping-----", "result content : " + stringBuffer.toString());
                // ping的状态
                int status = p.waitFor();
                if (status == 0) { 
                    result = "success";
                    return true;
                } else { 
                    result = "failed";
                }
            } catch (IOException e) { 
                result = "IOException";
            } catch (InterruptedException e) { 
                result = "InterruptedException";
            } finally { 
                Log.d("----result---", "result = " + result);
            }
            return false;
    
        }
    }

--------------------

**[转载请注明博客地址：][Link 1]http://blog.csdn.net/gdutxiaoxu/article/details/53008266**

**[源码下载地址：][Link 3]https://github.com/gdutxiaoxu/FunAPP.git**

**程序员徐公，希望让你看到程序猿不同的一面，除了分享 Coding，，还有职场心得，面试经验，学习心得，人生感悟等等。希望通过该公众号，我们不只会敲代码，我们还会。。。。。。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]

[Link 1]: http://blog.csdn.net/gdutxiaoxu/article/details/53008266
[Android]: /images/20220715/37d40e7946474218a25b5212bfc35455.png
[Link 2]: https://developer.android.com/reference/android/provider/Settings.html
[3c63abb06c7a8b97cb86d3028be006c3.gif]: /images/20220715/d7374cc05f0e4e94b0af44045d4071f3.png
[Android 1]: http://www.jianshu.com/p/10ed9ae02775
[Link 3]: https://github.com/gdutxiaoxu/FunAPP.git
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]: /images/20220715/a6e9f69c6488491f8a94486b07492397.png