Android 判断网络工具类

NetUtils:

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.location.LocationManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.util.Log;

import java.util.List;

/**
 * 作者：sgf on 2016/9/22 14:06
 * 说明:网络相关工具类
 */
public class NetUtils
{
    public enum netType
    {
        wifi, CMNET, CMWAP, noneNet
    }
    private NetUtils()
    {
        /* cannot be instantiated */
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * @方法说明:网络是否可用
     * @方法名称:isNetworkAvailable
     * @param context
     * @return
     * @返回值:boolean
     */
    public static boolean isNetworkAvailable(Context context) {
        if(context !=null){
            ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo info = cm.getActiveNetworkInfo();
            if(info !=null){
                return info.isAvailable();
            }
        }
        return false;
    }
    /**
     * 判断网络是否连接
     *
     * @param context
     * @return
     */
    public static boolean isConnected(Context context)
    {

        Log.e("aaaaaa",context+"");
        ConnectivityManager connectivity = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (null != connectivity)
        {

            NetworkInfo info = connectivity.getActiveNetworkInfo();
            if (null != info && info.isConnected())
            {
                if (info.getState() == NetworkInfo.State.CONNECTED)
                {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 判断是否是wifi连接
     */
    public static boolean isWifi(Context context)
    {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (cm == null)
            return false;
        return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;

    }

    /**
     * 打开网络设置界面
     */
    public static void openSetting(Activity activity)
    {
        Intent intent = new Intent("/");
        ComponentName cm = new ComponentName("com.android.settings",
                "com.android.settings.WirelessSettings");
        intent.setComponent(cm);
        intent.setAction("android.intent.action.VIEW");
        activity.startActivityForResult(intent, 0);
    }

    /**
     * 检查网络是否可用
     *
     * @param paramContext
     * @return
     */
    public static boolean checkEnable(Context paramContext) {
        boolean i = false;
        NetworkInfo localNetworkInfo = ((ConnectivityManager) paramContext
                .getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        if ((localNetworkInfo != null) && (localNetworkInfo.isAvailable()))
            return true;
        return false;
    }

    /**
     * 将ip的整数形式转换成ip形式
     *
     * @param ipInt
     * @return
     */
    public static String int2ip(int ipInt) {
        StringBuilder sb = new StringBuilder();
        sb.append(ipInt & 0xFF).append(".");
        sb.append((ipInt >> 8) & 0xFF).append(".");
        sb.append((ipInt >> 16) & 0xFF).append(".");
        sb.append((ipInt >> 24) & 0xFF);
        return sb.toString();
    }

    /**
     * 获取当前ip地址
     *
     * @param context
     * @return
     */
    public static String getLocalIpAddress(Context context) {
        try {
            // for (Enumeration<NetworkInterface> en = NetworkInterface
            // .getNetworkInterfaces(); en.hasMoreElements();) {
            // NetworkInterface intf = en.nextElement();
            // for (Enumeration<InetAddress> enumIpAddr = intf
            // .getInetAddresses(); enumIpAddr.hasMoreElements();) {
            // InetAddress inetAddress = enumIpAddr.nextElement();
            // if (!inetAddress.isLoopbackAddress()) {
            // return inetAddress.getHostAddress().toString();
            // }
            // }
            // }

            WifiManager wifiManager = (WifiManager) context
                    .getSystemService(Context.WIFI_SERVICE);
            WifiInfo wifiInfo = wifiManager.getConnectionInfo();
            int i = wifiInfo.getIpAddress();
            return int2ip(i);
        } catch (Exception ex) {
            return " 获取IP出错鸟!!!!请保证是WIFI,或者请重新打开网络!\n" + ex.getMessage();
        }
        // return null;
    }
    /**
     * @方法说明:判断是否是手机网络
     * @方法名称:is3GNet
     * @param context
     * @return
     * @返回值:boolean
     */
    public static boolean is3GNet(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;
    }

    /**
     * @方法说明:获取当前的网络状态 -1：没有网络 1：WIFI网络2：wap 网络3：net网络
     * @方法名称:getAPNType
     * @param context
     * @return
     * @返回值:netType
     */
    public static netType getAPNType(Context context)
    {
        ConnectivityManager connMgr = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        if (networkInfo == null)
        {
            return netType.noneNet;
        }
        int nType = networkInfo.getType();

        if (nType == ConnectivityManager.TYPE_MOBILE)
        {
            if (networkInfo.getExtraInfo().toLowerCase().equals("cmnet"))
            {
                return netType.CMNET;
            }

            else
            {
                return netType.CMWAP;
            }
        } else if (nType == ConnectivityManager.TYPE_WIFI)
        {
            return netType.wifi;
        }
        return netType.noneNet;

    }
    /**
     * @方法说明:获取当前网络连接的类型信息
     * @方法名称:getConnectedType
     * @param context
     * @return
     * @返回值:int
     */
    public static int getConnectedType(Context context)
    {
        if (context != null)
        {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager
                    .getActiveNetworkInfo();
            if (mNetworkInfo != null && mNetworkInfo.isAvailable())
            {
                return mNetworkInfo.getType();
            }
        }
        return -1;
    }

    /**
     * @方法说明:判断MOBILE网络是否可用
     * @方法名称:isMobileConnected
     * @param context
     * @return
     * @返回值:boolean
     */
    public static boolean isMobileConnected(Context context)
    {
        if (context != null)
        {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mMobileNetworkInfo = mConnectivityManager
                    .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            if (mMobileNetworkInfo != null)
            {
                return mMobileNetworkInfo.isAvailable();
            }
        }
        return false;
    }

    /**
     * Gps是否打开
     *
     * @param context
     * @return
     */
    public static boolean isGpsEnabled(Context context) {
        LocationManager locationManager = ((LocationManager) context
                .getSystemService(Context.LOCATION_SERVICE));
        List<String> accessibleProviders = locationManager.getProviders(true);
        return accessibleProviders != null && accessibleProviders.size() > 0;
    }


}

import android.content.Context;  
import android.content.Intent;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
import android.telephony.TelephonyManager;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by sgf on 2016/9/1. 
 */  
public class NetworkUtils {  
  
    private NetworkUtils() {  
        throw new UnsupportedOperationException(“u can’t instance me…”);  
    }  
  
    public static final int NETWORK_WIFI = 1;    // wifi network  
    public static final int NETWORK_4G = 4;    // “4G” networks  
    public static final int NETWORK_3G = 3;    // “3G” networks  
    public static final int NETWORK_2G = 2;    // “2G” networks  
    public static final int NETWORK_UNKNOWN = 5;    // unknown network  
    public static final int NETWORK_NO = -1;   // no network  
  
    private static final int NETWORK_TYPE_GSM = 16;  
    private static final int NETWORK_TYPE_TD_SCDMA = 17;  
    private static final int NETWORK_TYPE_IWLAN = 18;  
  
    public static List<String> typeList = new ArrayList<>();  
    static  
    {  
        typeList.add(”打开网络设置界面”);  
        typeList.add(”获取活动网络信息”);  
        typeList.add(”判断网络是否可用”);  
        typeList.add(”判断网络是否是4G”);  
        typeList.add(”判断wifi是否连接状态”);  
        typeList.add(”获取移动网络运营商名称”);  
        typeList.add(”获取当前的网络类型”);  
        typeList.add(”获取当前的网络类型(WIFI,2G,3G,4G)”);  
  
  
  
  
  
  
  
    }  
    /** 
     * 打开网络设置界面 
     * <p>3.0以下打开设置界面</p> 
     * 
     * @param context 上下文 
     */  
    public static void openWirelessSettings(Context context) {  
        if (android.os.Build.VERSION.SDK_INT > 10) {  
            context.startActivity(new Intent(android.provider.Settings.ACTION_SETTINGS));  
        } else {  
            context.startActivity(new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS));  
        }  
    }  
  
    /** 
     * 获取活动网络信息 
     * 
     * @param context 上下文 
     * @return NetworkInfo 
     */  
    public static NetworkInfo getActiveNetworkInfo(Context context) {  
        ConnectivityManager cm = (ConnectivityManager) context  
                .getSystemService(Context.CONNECTIVITY_SERVICE);  
        return cm.getActiveNetworkInfo();  
    }  
  
    /** 
     * 判断网络是否可用 
     * <p>需添加权限 {@code <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE”/>}</p> 
     * 
     * @param context 上下文 
     * @return {@code true}: 可用<br>{@code false}: 不可用 
     */  
    public static boolean isAvailable(Context context) {  
        NetworkInfo info = getActiveNetworkInfo(context);  
        return info != null && info.isAvailable();  
    }  
  
    /** 
     * 判断网络是否连接 
     * <p>需添加权限 {@code <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE”/>}</p> 
     * 
     * @param context 上下文 
     * @return {@code true}: 是<br>{@code false}: 否 
     */  
    public static boolean isConnected(Context context) {  
        NetworkInfo info = getActiveNetworkInfo(context);  
        return info != null && info.isConnected();  
    }  
  
    /** 
     * 判断网络是否是4G 
     * <p>需添加权限 {@code <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE”/>}</p> 
     * 
     * @param context 上下文 
     * @return {@code true}: 是<br>{@code false}: 不是 
     */  
    public static boolean is4G(Context context) {  
        NetworkInfo info = getActiveNetworkInfo(context);  
        return info != null && info.isAvailable() && info.getSubtype() == TelephonyManager.NETWORK_TYPE_LTE;  
    }  
  
    /** 
     * 判断wifi是否连接状态 
     * <p>需添加权限 {@code <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE”/>}</p> 
     * 
     * @param context 上下文 
     * @return {@code true}: 连接<br>{@code false}: 未连接 
     */  
    public static boolean isWifiConnected(Context context) {  
        ConnectivityManager cm = (ConnectivityManager) context  
                .getSystemService(Context.CONNECTIVITY_SERVICE);  
        return cm != null && cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;  
    }  
  
    /** 
     * 获取移动网络运营商名称 
     * <p>如中国联通、中国移动、中国电信</p> 
     * 
     * @param context 上下文 
     * @return 移动网络运营商名称 
     */  
    public static String getNetworkOperatorName(Context context) {  
        TelephonyManager tm = (TelephonyManager) context  
                .getSystemService(Context.TELEPHONY_SERVICE);  
        return tm != null ? tm.getNetworkOperatorName() : null;  
    }  
  
    /** 
     * 获取移动终端类型 
     * 
     * @param context 上下文 
     * @return 手机制式 
     * <ul> 
     * <li>{@link TelephonyManager#PHONE_TYPE_NONE } : 0 手机制式未知</li> 
     * <li>{@link TelephonyManager#PHONE_TYPE_GSM  } : 1 手机制式为GSM，移动和联通</li> 
     * <li>{@link TelephonyManager#PHONE_TYPE_CDMA } : 2 手机制式为CDMA，电信</li> 
     * <li>{@link TelephonyManager#PHONE_TYPE_SIP  } : 3</li> 
     * </ul> 
     */  
    public static int getPhoneType(Context context) {  
        TelephonyManager tm = (TelephonyManager) context  
                .getSystemService(Context.TELEPHONY_SERVICE);  
        return tm != null ? tm.getPhoneType() : -1;  
    }  
  
  
    /** 
     * 获取当前的网络类型(WIFI,2G,3G,4G) 
     * <p>需添加权限 {@code <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE”/>}</p> 
     * 
     * @param context 上下文 
     * @return 网络类型 
     * <ul> 
     * <li>{@link #NETWORK_WIFI   } = 1;</li> 
     * <li>{@link #NETWORK_4G     } = 4;</li> 
     * <li>{@link #NETWORK_3G     } = 3;</li> 
     * <li>{@link #NETWORK_2G     } = 2;</li> 
     * <li>{@link #NETWORK_UNKNOWN} = 5;</li> 
     * <li>{@link #NETWORK_NO     } = -1;</li> 
     * </ul> 
     */  
    public static int getNetWorkType(Context context) {  
        int netType = NETWORK_NO;  
        NetworkInfo info = getActiveNetworkInfo(context);  
        if (info != null && info.isAvailable()) {  
  
            if (info.getType() == ConnectivityManager.TYPE_WIFI) {  
                netType = NETWORK_WIFI;  
            } else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {  
                switch (info.getSubtype()) {  
  
                    case NETWORK_TYPE_GSM:  
                    case TelephonyManager.NETWORK_TYPE_GPRS:  
                    case TelephonyManager.NETWORK_TYPE_CDMA:  
                    case TelephonyManager.NETWORK_TYPE_EDGE:  
                    case TelephonyManager.NETWORK_TYPE_1xRTT:  
                    case TelephonyManager.NETWORK_TYPE_IDEN:  
                        netType = NETWORK_2G;  
                        break;  
  
                    case NETWORK_TYPE_TD_SCDMA:  
                    case TelephonyManager.NETWORK_TYPE_EVDO_A:  
                    case TelephonyManager.NETWORK_TYPE_UMTS:  
                    case TelephonyManager.NETWORK_TYPE_EVDO_0:  
                    case TelephonyManager.NETWORK_TYPE_HSDPA:  
                    case TelephonyManager.NETWORK_TYPE_HSUPA:  
                    case TelephonyManager.NETWORK_TYPE_HSPA:  
                    case TelephonyManager.NETWORK_TYPE_EVDO_B:  
                    case TelephonyManager.NETWORK_TYPE_EHRPD:  
                    case TelephonyManager.NETWORK_TYPE_HSPAP:  
                        netType = NETWORK_3G;  
                        break;  
  
                    case NETWORK_TYPE_IWLAN:  
                    case TelephonyManager.NETWORK_TYPE_LTE:  
                        netType = NETWORK_4G;  
                        break;  
                    default:  
  
                        String subtypeName = info.getSubtypeName();  
                        if (subtypeName.equalsIgnoreCase(“TD-SCDMA”)  
                                || subtypeName.equalsIgnoreCase(”WCDMA”)  
                                || subtypeName.equalsIgnoreCase(”CDMA2000”)) {  
                            netType = NETWORK_3G;  
                        } else {  
                            netType = NETWORK_UNKNOWN;  
                        }  
                        break;  
                }  
            } else {  
                netType = NETWORK_UNKNOWN;  
            }  
        }  
        return netType;  
    }  
  
    /** 
     * 获取当前的网络类型(WIFI,2G,3G,4G) 
     * <p>依赖上面的方法</p> 
     * 
     * @param context 上下文 
     * @return 网络类型名称 
     * <ul> 
     * <li>NETWORK_WIFI   </li> 
     * <li>NETWORK_4G     </li> 
     * <li>NETWORK_3G     </li> 
     * <li>NETWORK_2G     </li> 
     * <li>NETWORK_UNKNOWN</li> 
     * <li>NETWORK_NO     </li> 
     * </ul> 
     */  
    public static String getNetWorkTypeName(Context context) {  
        switch (getNetWorkType(context)) {  
            case NETWORK_WIFI:  
                return “NETWORK_WIFI”;  
            case NETWORK_4G:  
                return “NETWORK_4G”;  
            case NETWORK_3G:  
                return “NETWORK_3G”;  
            case NETWORK_2G:  
                return “NETWORK_2G”;  
            case NETWORK_NO:  
                return “NETWORK_NO”;  
            default:  
                return “NETWORK_UNKNOWN”;  
        }  
    }  
}