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

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

作者：Gausst松鼠会 | 2024-05-16 03:46:41

赞

踩

android 监听网络变化

本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布

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

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

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

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

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

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

Android 技术人

实现思路

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

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

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

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

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

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

静态注册

<receiver android:name=".network.NetworkConnectChangedReceiver">
    <intent-filter>
        <action android:name="android.NET.conn.CONNECTIVITY_CHANGE" />
        <action android:name="android.Net.wifi.WIFI_STATE_CHANGED" />
        <action android:name="android.net.wifi.STATE_CHANGE" />
    </intent-filter>
</receiver>



  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

动态注册

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

<receiver android:name=".network.NetworkConnectChangedReceiver">
        </receiver>

  • 1
  • 2

第二步：调用 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);




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

我们自定义的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);

            }


        }
    }


}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107

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

<uses-permission android:name="android.permission.INTERNET"/>
 
 <!--允许读取网络状态-->
 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
<!--允许读取wifi网络状态-->
 <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

思路解析

从上面的代码中，我们可以知道我们将我们当前的网络状态保存在我们的 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);

  • 1
  • 2

获取 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);

}




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

第二种方法

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);

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

网络错误情况的处理

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

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

第一种做法：
在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();


}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

这里对几个 重要的 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，请参考官网地址

需要注意的是

若我们 使用的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中添加以下权限 。
 <!--允许 弹出系统级别的AlterDialog-->
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

智能无图

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

效果图如下

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

实现的核心代码如下

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

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


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

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


  • 1
  • 2
  • 3

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);
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

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

拓展工具类

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

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;

    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272

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

源码下载地址：https://github.com/gdutxiaoxu/FunAPP.git

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

在这里插入图片描述

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

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

  

闽ICP备14008679号