android 监听网络状态的变化及实际应用

最新推荐文章于 2024-02-26 16:04:40 发布
最新推荐文章于 2024-02-26 16:04:40 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Android

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

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

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

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

实现思路

在网络错误的情况下获取网络状态进行判断，这种方法是可行的，但你想过了没有，如果每次都要进行这样的判断，岂不是代码量很多？有人会说，那把代码封装到一个类不就好了吗？这样确实能减少代码量，但是每次都要主动去获取，这样是不是挺麻烦的。实际上，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设置界面或者打开移动网络界面 ， 下面我们我们一起来看一下 怎样弹出一个对话框，并且跳转到相应的设置界面

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

代码如下

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

IT_大仙
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 广播监听网络状态详解及实例代码
01-20
Android 广播监听网络状态 我们在做多线程下载的时候，或者是在加载h5界面的时候，常常会遇到网络状态不好或者断网的时候，在这或者当我们的应用程序启动没有退出的时候，我们就需要对网络状态监听加以判断。 这时候，我们一般情况下，两种方式进行处理。 第一： 开启服务。 第二：发送广播的形式。 建议采用方法二。 源代码如下： 广播： /** * 有网络的广播 */ BroadcastReceiver connectionReceiver = new BroadcastReceiver() { @Override public void onRece
android 监听网络状态的变化及实战的示例代码
08-28
本篇文章主要介绍了android 监听网络状态的变化及实战的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Android 监听网络状态变化
最新发布
xiangxiongfly
02-26 679
Android 监听网络状态变化
在Android中监听网络连接的简单方法
虎哥LoveDroid
04-11 2232
要使用 Kotlin 监控 Android 中的互联网连接，您可以使用该类，这是一个允许您查询网络状态的系统服务。RxAndroid。
android 监听网络状态的变化及实战
热门推荐
徐公，微信公众号同名
11-02 4万+
今天这篇博客主要阐述以下问题 怎样监听网络状态的变化，包括是否打开WiFi，否打开数据网络，当前连接的网络是否可用 网络没有打开情况下的处理,如弹出对话框，跳转到 打开 WiFi设置的界面等 非WiFi情况下是否 非WiFi情况下是否加载图片，是否播放视频等
Android网络状态变化监听 -- 结合registerNetworkCallback和广播(kotlin)
qq_36162336的博客
12-30 3571
android 监听网络状态kotlin实现
Android监听网络变化
Android菜鸟的专栏
02-22 4383
小于Android5.0的版本 小于Android5.0的监听方式，使用广播接收者的方式，代码如下： context.registerReceiver(ConnectivityReceiver(), IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)) // 监听连接改变 class ConnectivityReceiver: BroadcastReceiver() { /** 指示是否没有网络 */ var noConnectiv
android.net.wifi的简单使用方法
liu149339750的专栏
09-19 3万+
获取Wifi的控制类WifiManager。  WifiManager  wm=(WifiManager)getSystemService(Context.WIFI_SERVICE); 接下来可以对wifi操作了，比如要打开、关闭wifi，可以通过WifiManager的setWifiEnabled（）方法来开关wifi。 若要查看一些信息，可以通过getConnectionInfo()方法
Android检测网络状态&监听网络变化
guodashen007的博客
12-14 1万+
网络状态改变、用户信息改变（帐户的钱），第一时间就要想到用观察者模式来实现 广播接收者，简单地把网络的变化通过接口抛出去 package com.qkt.face.et.receiver; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.
Android开发——监听Android手机的网络状态
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
12-30 6284
0. 前言在Android开发中监听手机的网络状态是一个常见的功能，比如在没网的状态下进行提醒并引导用户打开网络设置，或者在非wifi状态下开启无图模式等等。因此本篇将网上的资料进行了整理总结，方便以后用到的时候可以快速地获取到手机的网络状态。1．主动获取之所以叫主动获取，是获取网络状态的时机是我们来定的，因此主动获取的代码位置比较灵活，可以是加载网络数据前，也可以在刚开启APP时，若没网则...
Android 实时监测（监听）网络连接状态变化
11-28
android网络监听变化，判断当前是什么网络类型，实时监听。android网络监听变化，判断当前是什么网络类型，实时监听。android网络监听变化，判断当前是什么网络类型，实时监听。android网络监听变化，判断当前是什么...
Android 监听网络连接状态，判断网络连接方式，9.0网络连接，获取已连接WiFi名称SSID和MAC，2.4G和5G以及单双频WiFi判断
meixi_android的博客
05-27 7114
1、添加权限 <uses-permission android:name="android.permission.INTERNET"/> <!-- 网络状态 --> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
Android 监听网络状态变化（无切换中间态版）
主营Android，副营Flutter、前端
01-16 1056
ConnectivityManager#registerNetworkCallback() 是监听所有网络变换的，监听范围广，但无法得知当前“系统默认网络”是什么，可以实现判断网络状态，但无法判断网络类型。广播监听 与 ConnectivityManager#registerDefaultNetworkCallback() 都是监听“系统默认网络”，所以可以实现网络状态与类型的判断，但都存在重复回调的情况，所以要做过滤处理，以及“系统默认网络”切换到普通网络时会有偶现短暂“无网络”状态，需要做延迟处理。
Android应用实时监听网络状态
WormholeStack
05-21 6192
在Android开发中我们肯定会遇到需要监听网络状态的时候，那我们应该怎么实现呢？ 老规矩先上效果图 实现思路，使用广播监听网络状态，接口回调展示状态。 首先我们需要用到的权限 <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.RECORD_AUDIO" /> <!-- 读取网络信息状态 -->
Android 广播监听WiFi的状态小结
h_025的博客
04-08 1554
这段时间在学习一下WiFi开发这个模块，果然自己摸索处处都是坑。   今天就对Android WiFi开发的学习来个小结：  1、 一般正常的项目开发中，是使用广播来监听WiFi的状态的 IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction("android.net.w
Android网络监听
牛永志的专栏
10-11 982
Android 网络变化监听的两种实现方式
网络状态变化监听 -- 结合registerNetworkCallback和广播(kotlin)
chuyouyinghe的专栏
10-17 514
AndroidAndroid针对网络状态变化的监听，在应用内我们通用需要监听设备网络状态的变化，作出相应的业务处理，需要一个方便的、全局的监听实现。。   针对不同设备的系统版本，使用不同的API方法实现；   注意使用广播监听网络状态在高版本的适配问题；
Android 中监听WIFI连接状态变化
Tom的博客
03-20 3万+
Android应用开发过程中通过注册广播监听Wifi状态变化： 广播中获取的action为WifiManager.WIFI_STATE_CHANGED_ACTION用于监听Android Wifi打开或关闭的状态，WifiManager.NETWORK_STATE_CHANGED_ACTION用于判断是否连接到了有效wifi（不能用于判断是否能够连接互联网）。 在收到action 为WifiMa
CarSystemUI 如何监听 应用是否为全屏
06-10
在 Android Auto 中，应用可以使用 CarExtender API 启用全屏模式，这时 CarSystemUI 会监听应用的全屏状态并做出相应的处理。 具体来说，CarSystemUI 可以通过监听 `WindowManager.LayoutParams` 中的 `FLAG_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值