android 监听网络状态的变化及实战的示例代码

发布时间：2020-10-07 10:30:03 来源：脚本之家阅读：294 作者：gdutxiaoxu 栏目：移动开发

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

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

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

怎样监听网络状态的变化，包括是否打开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>

动态注册

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

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

第二步：调用 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>
<!--允许读取wifi网络状态-->
 <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设置界面或者打开移动网络界面，下面我们我们一起来看一下怎样弹出一个对话框，并且跳转到相应的设置界面

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

android 监听网络状态的变化及实战的示例代码

代码如下

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，请参考官网地址

需要注意的是

若我们使用的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"/>

智能无图

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

效果图如下

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

android 监听网络状态的变化及实战的示例代码

实现的核心代码如下

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，是通过监听广播实现的，前面已经说明了，这里就不再阐述了。

拓展工具类

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;

  }
}

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

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持亿速云。

向AI问一下细节

android 监听网络状态的变化及实战的示例代码

猜你喜欢

最新资讯

相关推荐

相关标签