Android.网络连接状态（联网,2g,3g,wifi等）

た 入场券 2022-06-04 07:36 323阅读 0赞

net与wap什么意思

WAP上网所谓WAP（Wireless Application Protocol)即无线应用协议，是一项全球性的网络通信协议。WAP使移动Internet 有了一个通行的标准，其目标是将Internet的丰富信息及先进的业务引入到移动电话等无线终端之中。WAP定义可通用的平台，把目前Internet网上HTML语言的信息转换成用WML（Wireless Markup Language)描述的信息，显示在移动电话的显示屏上。WAP只要求移动电话和WAP代理服务器的支持，而不要求现有的移动通信网络协议做任何的改动，因而可以广泛的运用于GSM、CDMA、TDMA、3G等多种网络。
NET是微软下一代的操作平台，它允许人们在其上构建各种应用方式，使人们尽可能通过简单的方式，多样化地、最大限度地从网站获取信息，解决网站之间的协同工作，并打破目前计算机、设备、网站、各大机构和工业界间的障碍－－即所谓的“数字孤岛”，从而实现因特网的全部潜能，搭建起第三代互联网平台。

Android如何判断当前网络类型

一般对网络的判断都是判断是否联网，不过有时候我们需要知道具体的网络类型，比如在3g网络下，百度地图的定位功能存在很大的偏差，这就需要提前判断网络类型针对3g网络情况做特殊的处理。

在android中判断网络需要用到ConnectivityManager，下面的方法演示了如何用ConnectivityManager**判断当前是否联网**：

  1. public static boolean isNetworkConnected() {
  2. ConnectivityManager cm = (ConnectivityManager) AppContext.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
  3. NetworkInfo ni = cm.getActiveNetworkInfo();
  4. return ni != null && ni.isConnectedOrConnecting();
  5. }

其中有个疑问，isConnectedOrConnecting()从字面上看是是否连接或者正在连接，如果正在连接的是一个不可用的网络，那应该算不联网的吧 ，所以我觉得还是改成isConnected()好些，根据个人的需求吧。

上面只是判断是否联网，跟我们的目的还有很大的差距，为了获得具体的网络类型需要对NetworkInfo中的信息进一步分解，NetworkInfo的getTypeName()方法可以判断出是wifi还是mobile网络，与getTypeName()方法对应的是getType方法，返回的是代表连接类型的整形常量，api中标明的有

ConnectivityManager.TYPE_MOBILE,
ConnectivityManager.TYPE_WIFI,
ConnectivityManager.TYPE_WIMAX,
ConnectivityManager.TYPE_ETHERNET,
ConnectivityManager.TYPE_BLUETOOTH

五种，其中只有ConnectivityManager.TYPE_MOBILE, ConnectivityManager.TYPE_WIFI是跟互联网有关的，可见ConnectivityManager并不是专门管理互联网连接的，还负责蓝牙等连接。

先定义一些整形变量代表不同的网络：

  1. /** 没有网络 */
  2. public static final int NETWORKTYPE_INVALID = 0;
  3. /** wap网络 */
  4. public static final int NETWORKTYPE_WAP = 1;
  5. /** 2G网络 */
  6. public static final int NETWORKTYPE_2G = 2;
  7. /** 3G和3G以上网络，或统称为快速网络 */
  8. public static final int NETWORKTYPE_3G = 3;
  9. /** wifi网络 */
  10. public static final int NETWORKTYPE_WIFI = 4;

这些常量将在后面用到。

下面我们通过一个方法来实现判断是wifi还是移动网络，如果是移动网络再通过其他方法进一步分析是3g还是2g：

  1. /** * 获取网络状态，wifi,wap,2g,3g. * * @param context 上下文 * @return int 网络状态 { @link #NETWORKTYPE_2G},{ @link #NETWORKTYPE_3G}, *{ @link #NETWORKTYPE_INVALID},{ @link #NETWORKTYPE_WAP}* <p>{ @link #NETWORKTYPE_WIFI} */
  2.     public static int getNetWorkType(Context context) {
  3.         ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
  4.         NetworkInfo networkInfo = manager.getActiveNetworkInfo();
  5.         if (networkInfo != null && networkInfo.isConnected()) {
  6.             String type = networkInfo.getTypeName();
  7.             if (type.equalsIgnoreCase("WIFI")) {
  8.                 mNetWorkType = NETWORKTYPE_WIFI;
  9.             } else if (type.equalsIgnoreCase("MOBILE")) {
  10.                 String proxyHost = android.net.Proxy.getDefaultHost();
  11.                 mNetWorkType = TextUtils.isEmpty(proxyHost)
  12.                         ? (isFastMobileNetwork(context) ? NETWORKTYPE_3G : NETWORKTYPE_2G)
  13.                         : NETWORKTYPE_WAP;
  14.             }
  15.         } else {
  16.             mNetWorkType = NETWORKTYPE_INVALID;
  17.         }
  18.         return mNetWorkType;
  19.     }

其中为了区别是3g还是2g我们定义了isFastMobileNetwork(context)方法，主要用到了TelephonyManager：

  1. private static boolean isFastMobileNetwork(Context context) {
  2. TelephonyManager telephonyManager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
  3.     switch (telephonyManager.getNetworkType()) {
  4.         case TelephonyManager.NETWORK_TYPE_1xRTT:
  5.             return false; // ~ 50-100 kbps
  6.         case TelephonyManager.NETWORK_TYPE_CDMA:
  7.             return false; // ~ 14-64 kbps
  8.         case TelephonyManager.NETWORK_TYPE_EDGE:
  9.             return false; // ~ 50-100 kbps
  10.         case TelephonyManager.NETWORK_TYPE_EVDO_0:
  11.             return true; // ~ 400-1000 kbps
  12.         case TelephonyManager.NETWORK_TYPE_EVDO_A:
  13.             return true; // ~ 600-1400 kbps
  14.         case TelephonyManager.NETWORK_TYPE_GPRS:
  15.             return false; // ~ 100 kbps
  16.         case TelephonyManager.NETWORK_TYPE_HSDPA:
  17.             return true; // ~ 2-14 Mbps
  18.         case TelephonyManager.NETWORK_TYPE_HSPA:
  19.             return true; // ~ 700-1700 kbps
  20.         case TelephonyManager.NETWORK_TYPE_HSUPA:
  21.             return true; // ~ 1-23 Mbps
  22.         case TelephonyManager.NETWORK_TYPE_UMTS:
  23.             return true; // ~ 400-7000 kbps
  24.         case TelephonyManager.NETWORK_TYPE_EHRPD:
  25.             return true; // ~ 1-2 Mbps
  26.         case TelephonyManager.NETWORK_TYPE_EVDO_B:
  27.             return true; // ~ 5 Mbps
  28.         case TelephonyManager.NETWORK_TYPE_HSPAP:
  29.             return true; // ~ 10-20 Mbps
  30.         case TelephonyManager.NETWORK_TYPE_IDEN:
  31.             return false; // ~25 kbps
  32.         case TelephonyManager.NETWORK_TYPE_LTE:
  33.             return true; // ~ 10+ Mbps
  34.         case TelephonyManager.NETWORK_TYPE_UNKNOWN:
  35.             return false;
  36.         default:
  37.             return false;
  38.         }
  39.     }

整个过程可总结为：第一步通过ConnectivityManager判断是wifi还是mobile网络，在通过TelephonyManager判断移动网络的类型。

具体实现监控网络

  1. package com.zgrb.integrationse_ysl.service;
  3. import android.app.Service;
  4. import android.content.BroadcastReceiver;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.content.IntentFilter;
  8. import android.net.ConnectivityManager;
  9. import android.net.NetworkInfo;
  10. import android.os.IBinder;
  11. import android.util.Log;
  12. import com.zgrb.integrationse_ysl.HomeActivity;
  13. import com.zgrb.integrationse_ysl.util.Common;
  14. import com.zgrb.integrationse_ysl.util.LogUtil;
  16. public class NetworkService extends Service { 
  17.     private static String TAG = "NetworkService";
  18.     private ConnectivityManager connectivityManager;
  19.     private NetworkInfo networkInfo;
  21.     private BroadcastReceiver NetworkReceiver = new BroadcastReceiver() {
  23.         @Override
  24.         public void onReceive(Context context, Intent intent) {
  25.             String action = intent.getAction();
  26.             LogUtil.i(TAG, "======网络广播======");
  27.             if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
  28.                 Log.d(TAG, "==网络状态改变");
  29.                 connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
  30.                 networkInfo = connectivityManager.getActiveNetworkInfo();
  31.                 if (networkInfo != null && networkInfo.isAvailable()) {
  32.                     String name = networkInfo.getTypeName();
  33.                     LogUtil.i(TAG, "==当前使用网络:" + name);
  34.                     Common.isNetwordAvailable = true;
  35.                 } else {
  36.                     Common.isNetwordAvailable = false;
  37.                     LogUtil.e(TAG, "==没有可用网络==");
  38.                 }
  39.                 HomeActivity.showView(context);
  40.             }
  41.         }
  43.     };
  45.     private static final String NFCADAPTER_EXTRA_STATE = "android.nfc.extra.ADAPTER_STATE";
  46.     private static final int STATE_OFF = 1;
  47.     // private static final int STATE_TURNING_ON = 2;
  48.     private static final int STATE_ON = 3;
  49.     // private static final int STATE_TURNING_OFF = 4;
  50.     private BroadcastReceiver NfcReceiver = new BroadcastReceiver() {
  52.         @Override
  53.         public void onReceive(Context context, Intent intent) {
  55.             String action = intent.getAction();
  56.             Log.d(TAG, "== nfc action:" + action);
  57.             if (action.equals(nfcAction)) {
  58.                 int nfcState = intent.getIntExtra(NFCADAPTER_EXTRA_STATE, -1);
  59.                 Log.e(TAG, "==nfcState:" + nfcState);
  60.                 if (nfcState == STATE_ON) {
  61.                     Log.e(TAG, "==nfc is opened");
  62.                     Common.isNfcAvailable = true;
  63.                 } else if (nfcState == STATE_OFF) {
  64.                     Log.e(TAG, "==nfc is closed");
  65.                     Common.isNfcAvailable = false;
  66.                 }
  67.                 // HomeActivity.showView(context);
  68.             }
  69.         }
  70.     };
  72.     @Override
  73.     public IBinder onBind(Intent intent) {
  74.         return null;
  75.     }
  77.     @Override
  78.     public void onCreate() {
  79.         super.onCreate();
  80.         LogUtil.i(TAG, "===service==onCreate");
  81. // registerNfcReceiver();
  82.         registerNetworkReceiver();
  83.     }
  85.     private void registerNetworkReceiver() {
  86.         LogUtil.i(TAG, "==注册网络广播==");
  87.         IntentFilter intentFilter = new IntentFilter();
  88.         intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
  89.         registerReceiver(NetworkReceiver, intentFilter);
  90.     }
  92.     private String nfcAction = "android.nfc.action.ADAPTER_STATE_CHANGED";
  94.     private void registerNfcReceiver() {
  95.         Log.d(TAG, "==注册NFC广播==");
  96.         IntentFilter filter = new IntentFilter();
  97.         filter.addAction(nfcAction);
  98.         registerReceiver(NfcReceiver, filter);
  99.     }
  101.     @Override
  102.     public void onDestroy() {
  103.         super.onDestroy();
  104.         Log.d(TAG, "==解绑网络广播==");
  105.         unregisterReceiver(NetworkReceiver);
  106. // unregisterReceiver(NfcReceiver);
  107.     }
  109. }

源码

参考:http://blog.csdn.net/nanzhiwen666/article/details/8288433#

发表评论

表情：
评论列表 （有 0 条评论，323人围观）

还没有评论，来说两句吧...

相关阅读