Android-JSONUtil工具類
常用的Json工具類，包含Json轉換成實體、實體轉json字串、list集合轉換成json、陣列轉換成json

public class JSONUtil {

    private static final String TAG = JSONUtil.class.getSimpleName();

    private JSONUtil(){}

    private static Gson gson = new Gson();

    /**
     * 傳入一個頭部，獲取頭部管控中的所有String資訊
     * @return
 

     */
    public static String getHeadContext(String jsonData, String head) {
        String jsonObjectString = null;
        try {
            JSONObject jsonObject = new JSONObject(jsonData);
            jsonObjectString = jsonObject.get(head).toString();
            // LogUtil.d(TAG, "getHeadContext 只去頭部header的資料資訊：" + jsonObjectString);
 

        } catch (Exception e) {
            e.printStackTrace();
        }
        return jsonObjectString;
    }

    /**
     * 將一個物件轉換成一個Json字串
     * @param t
     * @return
     */
    public static <T> String objectToJson(T t){
        if (t instanceof String) {
            return t.toString();
        } else
 
 {
            return gson.toJson(t);
        }
    }

    /**
     * 將Json字串轉換成對應物件
     * @param jsonString    Json字串
     * @param clazz        對應位元組碼檔案.class
     * @return
     */
    @SuppressWarnings("unchecked")
    public static<T> T jsonToObject(String jsonString, Class<T> clazz){
        if (clazz == String.class) {
            return (T) jsonString;
        } else {
            return (T)gson.fromJson(jsonString, clazz);
        }
    }

    /**
     * 將List集合轉換為json字串
     * @param list    List集合
     * @return
     */
    public static<T> String listToJson(List<T> list){
        JSONArray jsonArray = new JSONArray();
        JSONObject jsonObject = null;
        try {
            for (int i = 0; i < list.size(); i++) {
                jsonObject = new JSONObject(objectToJson(list.get(i)));
                jsonArray.put(jsonObject);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        } finally {
            if (jsonObject != null) {
                jsonObject = null;
            }
        }
        return jsonArray.toString();
    }

    /**
     * 將陣列轉換成json字串
     * @param array        陣列
     * @return
     */
    public static<T> String arrayToJson(T[] array){
        JSONArray jsonArray = new JSONArray();
        JSONObject jsonObject = null;
        try {
            for (int i = 0; i < array.length; i++) {
                jsonObject = new JSONObject(objectToJson(array[i]));
                jsonArray.put(jsonObject);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        } finally {
            if (jsonObject != null) {
                jsonObject = null;
            }
        }
        return jsonArray.toString();
    }

    /**
     * 獲取json字串中的值
     * @param json    json字串
     * @param key    鍵值
     * @param clazz    所取資料型別，例如：Integer.class，String.class，Double.class，JSONObject.class
     * @return  存在則返回正確值，不存在返回null
     */
    public static<T> T getJsonObjectValue(String json, String key, Class<T> clazz){
        try {
            return getJsonObjectValue(new JSONObject(json), key, clazz);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 獲取jsonObject物件中的值
     * @param jsonObject    jsonObject物件
     * @param key    鍵值
     * @param clazz    所取資料型別，例如：Integer.class，String.class，Double.class，JSONObject.class
     * @return  存在則返回正確值，不存在返回null
     */
    @SuppressWarnings("unchecked")
    public static<T> T getJsonObjectValue(JSONObject jsonObject, String key, Class<T> clazz){
        T t = null;
        try {
            if (clazz == Integer.class) {
                t = (T) Integer.valueOf(jsonObject.getInt(key));
            }else if(clazz == Boolean.class){
                t = (T) Boolean.valueOf(jsonObject.getBoolean(key));
            }else if(clazz == String.class){
                t = (T) String.valueOf(jsonObject.getString(key));
            }else if(clazz == Double.class){
                t = (T) Double.valueOf(jsonObject.getDouble(key));
            }else if(clazz == JSONObject.class){
                t = (T) jsonObject.getJSONObject(key);
            }else if(clazz == JSONArray.class){
                t = (T) jsonObject.getJSONArray(key);
            }else if(clazz == Long.class){
                t = (T) Long.valueOf(jsonObject.getLong(key));
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * json字串轉換為ContentValues
     * @param json    json字串
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static ContentValues jsonToContentValues(String json){
        ContentValues contentValues = new ContentValues();
        try {
            JSONObject jsonObject = new JSONObject(json);
            Iterator iterator = jsonObject.keys();
            String key;
            Object value;
            while (iterator.hasNext()) {
                key = iterator.next().toString();
                value = jsonObject.get(key);
                String valueString = value.toString();
                if (value instanceof String) {
                    contentValues.put(key, valueString);
                }else if(value instanceof Integer){
                    contentValues.put(key, Integer.valueOf(valueString));
                }else if(value instanceof Long){
                    contentValues.put(key, Long.valueOf(valueString));
                }else if(value instanceof Double){
                    contentValues.put(key, Double.valueOf(valueString));
                }else if(value instanceof Float){
                    contentValues.put(key, Float.valueOf(valueString));
                }else if(value instanceof Boolean){
                    contentValues.put(key, Boolean.valueOf(valueString));
                }
            }
        } catch (JSONException e) {
            e.printStackTrace();
            throw new Error("Json字串不合法：" + json);
        }

        return contentValues;
    }
}

Android-LogUtil工具類
Log日誌級別列印相關工具類

public class LogUtil {

    private LogUtil(){}

    /**
     * 列印的資訊日誌資訊
     */
    private final static String INFO = "☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻: ";

    /**
     * 列印的錯誤日誌資訊
     */
    private final static String ERROR = "✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖: ";

    /**
     * 列印的除錯日誌資訊
     */
    private final static String DEBUG = "☠☠☠☠☠☠☠☠☠☠☠☠☠☠☠: ";

    /**
     * 列印的全面日誌資訊
     */
    private final static String VERBOSE = "▂▂▂▃▃▄▄▅▅▆▆▆▇▇: ";

    /**
     * 列印的警告日誌資訊
     */
    private final static String WARN = "!!!!!!!!!!!!!!!!!!!!!!!!!!: ";

    /**
     * 列印information日誌
     * @param tag 標籤
     * @param msg 日誌資訊
     */
    public static void i(String tag,String msg){
        Log.i(tag, INFO + msg);
    }

    /**
     * 列印information日誌
     * @param tag    標籤
     * @param msg    日誌資訊
     * @param throwable    異常
     */
    public static void i(String tag, String msg, Throwable throwable){
        Log.i(tag, INFO + msg, throwable);
    }

    /**
     * 列印verbose日誌
     * @param tag    標籤
     * @param msg    日誌資訊
     */
    public static void v(String tag, String msg){
        Log.v(tag, VERBOSE + msg);
    }

    /**
     * 列印verbose日誌
     * @param tag    標籤
     * @param msg    日誌資訊
     * @param throwable    異常
     */
    public static void v(String tag, String msg, Throwable throwable){
        Log.v(tag, VERBOSE + msg, throwable);
    }

    /**
     * 列印debug資訊
     * @param tag    標籤資訊
     * @param msg    日誌資訊
     */
    public static void d(String tag, String msg){
        Log.d(tag, DEBUG + msg);
    }

    /**
     * 列印debug日誌
     * @param tag    標籤資訊
     * @param msg    日誌資訊
     * @param throwable    異常
     */
    public static void d(String tag, String msg, Throwable throwable){
        Log.d(tag, DEBUG + msg, throwable);
    }

    /**
     * 列印warn日誌
     * @param tag    標籤資訊
     * @param msg    日誌資訊
     */
    public static void w(String tag, String msg){
        Log.w(tag, WARN + msg);
    }

    /**
     * 列印warn日誌
     * @param tag    標籤資訊
     * @param msg    日誌資訊
     * @param throwable    異常
     */
    public static void w(String tag, String msg, Throwable throwable){
        Log.w(tag, WARN + msg, throwable);
    }

    /**
     * 列印error日誌
     * @param tag
     * @param msg    標籤
     */
    public static void e(String tag, String msg){
        Log.e(tag, ERROR + msg);
    }

    /**
     * 列印error日誌
     * @param tag    標籤
     * @param msg    日誌資訊
     * @param throwable    異常
     */
    public static void e(String tag, String msg, Throwable throwable){
        Log.e(tag, ERROR + msg, throwable);
    }

    /**
     * 吐司提示
     * @param msg
     */
    public static void toast(Context mContext, String msg) {
        Toast.makeText(mContext, msg, Toast.LENGTH_SHORT).show();
    }

    /**
     * 吐司提示 long型別
     * @param msg
     */
    public static void toastL(Context mContext, String msg) {
        Toast.makeText(mContext, msg, Toast.LENGTH_SHORT).show();
    }

    /**
     * 吐司提示 自定義時間型別
     * @param msg
     */
    public static void toastD(Context mContext, String msg, int duration) {
        Toast.makeText(mContext, msg, duration).show();
    }
}

Android-MD5Util工具類
MD5 字串加密 ，檔案加密相關工具類

public class MD5Util {

    private static final String TAG = "MD5Util";

    /**
     * 預設的密碼字串組合，用來將位元組轉換成 16 進製表示的字元,apache校驗下載的檔案的正確性用的就是預設的這個組合
     */
    protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

    protected static MessageDigest messagedigest = null;

    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsaex) {
            ELog.e(TAG, MD5Util.class.getName()
                    + "init failed ，MessageDigest un support MD5Util。");
            nsaex.printStackTrace();
        }
    }

    /**
     * 生成字串的md5校驗值
     * @param s
     * @return
     */
    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }

    /**
     * 生成字串的md5校驗值 16位
     * @param s
     * @return
     */
    public static String getMD5String16(String s) {
        return getMD5String(s.getBytes()).substring(8, 24);
    }

    /**
     * 判斷字串的md5校驗碼是否與一個已知的md5碼相匹配
     * @param password 要校驗的字串
     * @param md5PwdStr 已知的md5校驗碼
     * @return
     */
    public static boolean checkPassword(String password, String md5PwdStr) {
        String s = getMD5String(password);
        return s.equals(md5PwdStr);
    }

    /**
     * 生成檔案的md5校驗值
     * @param file
     * @return
     * @throws IOException
     */
    public static String getFileMD5String(File file) throws IOException {
        InputStream fis;
        fis = new FileInputStream(file);
        byte[] buffer = new byte[1024];
        int numRead = 0;
        while ((numRead = fis.read(buffer)) > 0) {
            messagedigest.update(buffer, 0, numRead);
        }
        fis.close();
        return bufferToHex(messagedigest.digest());
    }

    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }

    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }

    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l < k; l++) {
            appendHexPair(bytes[l], stringbuffer);
        }
        return stringbuffer.toString();
    }

    private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
        char c0 = hexDigits[(bt & 0xf0) >> 4];    // 取位元組中高 4 位的數字轉換, >>> 為邏輯右移，將符號位一起右移,此處未發現兩種符號有何不同 
        char c1 = hexDigits[bt & 0xf];    // 取位元組中低 4 位的數字轉換 
        stringbuffer.append(c0);
        stringbuffer.append(c1);
    }

    /**
     * 自測方法
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(getMD5String("test"));
    }
}

Android-MeasureUtil工具類
常用測量相關的工具類：

public class MeasureUtil {

    private MeasureUtil(){}

    /**
     * 獲取控制元件的測量高度
     * @param view    控制元件
     * @return    返回測量高度（MeasuredHeight）
     */
    public static int getMeasuredHeight(View view) {
        if (view == null) {
            throw new IllegalArgumentException("view is null");
        }
        view.measure(0, 0);
        return view.getMeasuredHeight();
    }

    /**
     * 控制元件的高度
     * @param view    控制元件View
     * @return    返回控制元件的高度
     */
    public static int getHeight(View view){
        if(view == null){
            throw new IllegalArgumentException("view is null");
        }

        view.measure(0, 0);
        return view.getHeight();
    }

    /**
     * 獲取控制元件的測量寬度
     * @param view    控制元件
     * @return    返回控制元件的測量寬度
     */
    public static int getMeasuredWidth(View view){
        if(view == null){
            throw new IllegalArgumentException("view is null");
        }

        view.measure(0, 0);
        return view.getMeasuredWidth();
    }

    /**
     * 獲取控制元件的寬度
     * @param view    控制元件
     * @return    返回控制元件的寬度
     */
    public static int getWidth(View view){
        if(view == null){
            throw new IllegalArgumentException("view is null");
        }

        view.measure(0, 0);
        return view.getWidth();
    }

    /**
     * 設定高度
     * @param view    控制元件
     * @param height    高度
     */
    public static void setHeight(View view, int height) {
        if (view == null || view.getLayoutParams() == null) {
            throw new IllegalArgumentException("View LayoutParams is null");
        }
        ViewGroup.LayoutParams params = view.getLayoutParams();
        params.height = height;
        view.setLayoutParams(params);
    }

    /**
     * 設定View的寬度
     * @param view    view
     * @param width    寬度
     */
    public static void setWidth(View view, int width){
        if(view == null || view.getLayoutParams() == null){
            throw new IllegalArgumentException("View LayoutParams is null");
        }

        ViewGroup.LayoutParams params = view.getLayoutParams();
        params.width = width;
        view.setLayoutParams(params);
    }

    /**
     * 設定ListView的實際高度
     * @param listView    ListView控制元件
     */
    public static void setListHeight(ListView listView) {
        if (listView == null) {
            throw new IllegalArgumentException("ListView is null");
        }
        Adapter adapter = listView.getAdapter();
        if (adapter == null) {
            return;
        }
        int totalHeight = 0;
        int size = adapter.getCount();
        for (int i = 0; i < size; i++) {
            View listItem = adapter.getView(i, null, listView);
            listItem.measure(0, 0);
            totalHeight += listItem.getMeasuredHeight();
        }
        ViewGroup.LayoutParams params = listView.getLayoutParams();
        params.height = totalHeight + (listView.getDividerHeight() * (size - 1));
        LogUtil.d("MeasureUtil", "listview-height--" + params.height);
        listView.setLayoutParams(params);
    }

    /**
     * 設定GridView的高度，
     * @param context    應用程式上下文
     * @param gv        GridView控制元件
     * @param n            行數
     * @param m            列數
     */
    public static void setGridViewHeight(Context context, GridView gv, int n, int m) {
        if(gv == null){
            throw new IllegalArgumentException("GridView is null");
        }
        Adapter adapter = gv.getAdapter();
        if (adapter == null) {
            return;
        }
        int totalHeight = 0;
        int size = adapter.getCount();
        for (int i = 0; i < size; i++) {
            View listItem = adapter.getView(i, null, gv);
            listItem.measure(0, 0);
            totalHeight += listItem.getMeasuredHeight() + ScreenUtil.dp2px(context, m);
        }
        ViewGroup.LayoutParams params = gv.getLayoutParams();
        params.height = totalHeight + gv.getPaddingTop() + gv.getPaddingBottom() + 2;
        LogUtil.d("MeasureUtil", "gridview-height--" + params.height);
        gv.setLayoutParams(params);
    }

}

Android-NetworkUtils工具類
網路型別，網路狀態，網路制式，等相關工具類

public final class NetworkUtils {
    private NetworkUtils() {
        throw new AssertionError();
    }

    /**
     * 未找到合適匹配網路型別
     */
    public static final int TYPE_NO = 0;

    /**
     * 中國移動CMNET網路
     * 中國移動GPRS接入方式之一, 主要為PC、膝上型電腦、PDA設立
     */
    public static final int TYPE_MOBILE_CMNET = 1;

    /**
     * 中國移動CMWAP網路
     * 中國移動GPRS接入方式之一,主要為手機WAP上網而設立
     */
    public static final int TYPE_MOBILE_CMWAP = 2;

    /**
     * 中國聯通UNIWAP網路
     * 中國聯通劃分GPRS接入方式之一, 主要為手機WAP上網而設立
     */
    public static final int TYPE_MOBILE_UNIWAP = 3;

    /**
     * 中國聯通UNINET網路
     * 中國聯通劃分GPRS接入方式之一, 主要為PC、膝上型電腦、PDA設立
     */
    public static final int TYPE_MOBILE_UNINET = 6;

    /**
     * 中國聯通3GWAP網路
     */
    public static final int TYPE_MOBILE_3GWAP = 4;

    // 中國聯通3HNET網路
    public static final int TYPE_MOBLIE_3GNET = 5;

    /**
     * 中國電信CTWAP網路
     */
    public static final int TYPE_MOBILE_CTWAP = 7;

    /**
     * 中國電信CTNET網路
     */
    public static final int TYPE_MOBILE_CTNET = 8;

    /**
     * WIFI網路
     */
    public static final int TYPE_WIFI = 10;

    /**
     * 網路型別 - 無連線
     */
    public static final int NETWORK_TYPE_NO_CONNECTION = -100000;

    /**
     * 連線模式WIFI網
     */
    public static final String NETWORK_TYPE_WIFI = "WIFI";
    /**
     * 連線模式快速網
     */
    public static final String NETWORK_TYPE_FAST = "FAST";
    /**
     * 連線模式慢速網
     */
    public static final String NETWORK_TYPE_SLOW = "SLOW";
    /**
     * 連線模式wap網
     */
    public static final String NETWORK_TYPE_WAP = "WAP";
    /**
     * 連線模式unknow
     */
    public static final String NETWORK_TYPE_UNKNOWN = "UNKNOWN";
    /**
     * 無連線
     */
    public static final String NETWORK_TYPE_DISCONNECT = "DISCONNECT";

    /**
     * 獲取當前手機連線的網路型別
     *
     * @param context 上下文
     * @return int 網路型別
     */
    public static int getNetworkState(Context context) {
        int returnValue = TYPE_NO;
        // 獲取ConnectivityManager物件
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        // 獲得當前網路資訊
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isAvailable()) {
            // 獲取網路型別
            int currentNetWork = networkInfo.getType();
            // 手機網路型別
            if (currentNetWork == ConnectivityManager.TYPE_MOBILE) {
                if (networkInfo.getExtraInfo() != null) {
                    if (networkInfo.getExtraInfo().equals("cmnet")) {
                        returnValue = TYPE_MOBILE_CMNET;
                    }
                    if (networkInfo.getExtraInfo().equals("cmwap")) {
                        returnValue = TYPE_MOBILE_CMWAP;
                    }
                    if (networkInfo.getExtraInfo().equals("uniwap")) {
                        returnValue = TYPE_MOBILE_UNIWAP;
                    }
                    if (networkInfo.getExtraInfo().equals("3gwap")) {
                        returnValue = TYPE_MOBILE_3GWAP;
                    }
                    if (networkInfo.getExtraInfo().equals("3gnet")) {
                        returnValue = TYPE_MOBLIE_3GNET;
                    }
                    if (networkInfo.getExtraInfo().equals("uninet")) {
                        returnValue = TYPE_MOBILE_UNINET;
                    }
                    if (networkInfo.getExtraInfo().equals("ctwap")) {
                        returnValue = TYPE_MOBILE_CTWAP;
                    }
                    if (networkInfo.getExtraInfo().equals("ctnet")) {
                        returnValue = TYPE_MOBILE_CTNET;
                    }
                }
                // WIFI網路型別
            } else if (currentNetWork == ConnectivityManager.TYPE_WIFI) {
                returnValue = TYPE_WIFI;
            }
        }
        return returnValue;
    }

    /**
     * 判斷網路是否連線
     *
     * @param context 上下文
     * @return boolean 網路連線狀態
     */
    public static boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager cm =
                    (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo info = cm.getActiveNetworkInfo();
            // 獲取連線物件
            if (null != info && info.isConnected()) {
                return info.getState() == State.CONNECTED;
            }
        }
        return false;
    }


    /**
     * 開啟網路設定介面
     *
     * @param activity Activity
     */
    public static void openNetSetting(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 context 上下文
     * @return 結果
     */
    public static boolean isFlowConnect(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (null == cm || null == cm.getActiveNetworkInfo()) {
            return false;
        }
        return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
    }

    /**
     * 是否是wifi連線
     *
     * @param context app的context
     * @return true:是wifi連線
     */
    public static boolean isWifiConnect(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (null == cm || null == cm.getActiveNetworkInfo()) {
            return false;
        }
        return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
    }

    /**
     * 獲取網路連線型別
     *
     * @param context context
     * @return NetworkType
     */
    public static int getNetworkType(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (null == cm || null == cm.getActiveNetworkInfo()) {
            return TYPE_NO;
        }
        return cm.getActiveNetworkInfo().getType();
    }


    /**
     * 獲取網路連線型別名稱
     *
     * @param context context
     * @return NetworkTypeName
     */
    public static String getNetworkTypeName(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = cm.getActiveNetworkInfo();
        String type = NETWORK_TYPE_DISCONNECT;
        if (cm == null || info == null) {
            return type;
        }
        if (info.isConnected()) {
            String typeName = info.getTypeName();
            if ("WIFI".equalsIgnoreCase(typeName)) {
                type = NETWORK_TYPE_WIFI;
            } else if ("MOBILE".equalsIgnoreCase(typeName)) {
                String proxyHost = android.net.Proxy.getDefaultHost();
                if (StringUtil.isEmpty(proxyHost)) {
                    type = isFastMobileNetwork(context) ? NETWORK_TYPE_FAST : NETWORK_TYPE_SLOW;
                } else {
                    type = NETWORK_TYPE_WAP;
                }
            } else {
                type = NETWORK_TYPE_UNKNOWN;
            }
        }
        return type;
    }


    /**
     * Whether is fast mobile network
     *
     * @param context context
     * @return FastMobileNetwork
     */
    private static boolean isFastMobileNetwork(Context context) {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(
                Context.TELEPHONY_SERVICE);
        if (telephonyManager == null) {
            return false;
        }

        switch (telephonyManager.getNetworkType()) {
            case TelephonyManager.NETWORK_TYPE_EVDO_0:
            case TelephonyManager.NETWORK_TYPE_EVDO_A:
            case TelephonyManager.NETWORK_TYPE_HSDPA:
            case TelephonyManager.NETWORK_TYPE_HSPA:
            case TelephonyManager.NETWORK_TYPE_HSUPA:
            case TelephonyManager.NETWORK_TYPE_UMTS:
            case TelephonyManager.NETWORK_TYPE_EHRPD:
            case TelephonyManager.NETWORK_TYPE_EVDO_B:
            case TelephonyManager.NETWORK_TYPE_HSPAP:
            case TelephonyManager.NETWORK_TYPE_LTE:
                return true;
            default:
                return false;
        }
    }


    /**
     * 獲取當前網路的狀態
     *
     * @param context 上下文
     * @return 當前網路的狀態。具體型別可參照NetworkInfo.State.CONNECTED、NetworkInfo.State.CONNECTED.DISCONNECTED等欄位。
     * 當前沒有網路連線時返回null
     */
    public static State getCurrentNetworkState(Context context) {
        NetworkInfo info = ((ConnectivityManager) context.getSystemService(
                Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        if (null == info) {
            return null;
        }
        return info.getState();
    }


    /**
     * 獲取當前網路的型別
     *
     * @param context 上下文
     * @return 當前網路的型別。具體型別可參照ConnectivityManager中的TYPE_BLUETOOTH、TYPE_MOBILE、TYPE_WIFI等欄位。
     * 當前沒有網路連線時返回NetworkUtils.NETWORK_TYPE_NO_CONNECTION
     */
    public static int getCurrentNetworkType(Context context) {
        NetworkInfo info = ((ConnectivityManager) context.getSystemService(
                Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        return info != null ? info.getType() : NETWORK_TYPE_NO_CONNECTION;
    }


    /**
     * 獲取當前網路的具體型別
     *
     * @param context 上下文
     * @return 當前網路的具體型別。具體型別可參照TelephonyManager中的NETWORK_TYPE_1xRTT、NETWORK_TYPE_CDMA等欄位。
     * 當前沒有網路連線時返回NetworkUtils.NETWORK_TYPE_NO_CONNECTION
     */
    public static int getCurrentNetworkSubtype(Context context) {
        NetworkInfo info = ((ConnectivityManager) context.getSystemService(
                Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        return info != null ? info.getSubtype() : NETWORK_TYPE_NO_CONNECTION;
    }


    /**
     * 判斷當前網路是否已經連線
     *
     * @param context 上下文
     * @return 當前網路是否已經連線。false：尚未連線
     */
    public static boolean isConnectedByState(Context context) {
        return getCurrentNetworkState(context) == State.CONNECTED;
    }


    /**
     * 判斷當前網路是否正在連線
     *
     * @param context 上下文
     * @return 當前網路是否正在連線
     */
    public static boolean isConnectingByState(Context context) {
        return getCurrentNetworkState(context) == State.CONNECTING;
    }


    /**
     * 判斷當前網路是否已經斷開
     *
     * @param context 上下文
     * @return 當前網路是否已經斷開
     */
    public static boolean isDisconnectedByState(Context context) {
        return getCurrentNetworkState(context) == State.DISCONNECTED;
    }


    /**
     * 判斷當前網路是否正在斷開
     *
     * @param context 上下文
     * @return 當前網路是否正在斷開
     */
    public static boolean isDisconnectingByState(Context context) {
        return getCurrentNetworkState(context) == State.DISCONNECTING;
    }


    /**
     * 判斷當前網路是否已經暫停
     *
     * @param context 上下文
     * @return 當前網路是否已經暫停
     */
    public static boolean isSuspendedByState(Context context) {
        return getCurrentNetworkState(context) == State.SUSPENDED;
    }


    /**
     * 判斷當前網路是否處於未知狀態中
     *
     * @param context 上下文
     * @return 當前網路是否處於未知狀態中
     */
    public static boolean isUnknownByState(Context context) {
        return getCurrentNetworkState(context) == State.UNKNOWN;
    }


    /**
     * 判斷當前網路的型別是否是藍芽
     *
     * @param context 上下文
     * @return 當前網路的型別是否是藍芽。false：當前沒有網路連線或者網路型別不是藍芽
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
    public static boolean isBluetoothByType(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
            return false;
        } else {
            return getCurrentNetworkType(context) == ConnectivityManager.TYPE_BLUETOOTH;
        }
    }


    /**
     * 判斷當前網路的型別是否是虛擬網路
     *
     * @param context 上下文
     * @return 當前網路的型別是否是虛擬網路。false：當前沒有網路連線或者網路型別不是虛擬網路
     */
    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    public static boolean isDummyByType(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
            return false;
        } else {
            return getCurrentNetworkType(context) == ConnectivityManager.TYPE_DUMMY;
        }
    }


    /**
     * 判斷當前網路的型別是否是ETHERNET
     *
     * @param context 上下文
     * @return 當前網路的型別是否是ETHERNET。false：當前沒有網路連線或者網路型別不是ETHERNET
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
    public static boolean isEthernetByType(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
            return false;
        } else {
            return getCurrentNetworkType(context) == ConnectivityManager.TYPE_ETHERNET;
        }
    }


    /**
     * 判斷當前網路的型別是否是行動網路
     *
     * @param context 上下文
     * @return 當前網路的型別是否是行動網路。false：當前沒有網路連線或者網路型別不是行動網路
     */
    public static boolean isMobileByType(Context context) {
        return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE;
    }


    /**
     * 判斷當前網路的型別是否是MobileDun
     *
     * @param context 上下文
     * @re