Android判断用户的网络类型(2/3/4G、wifi)

我会带着你远行 2022-05-26 03:05 208阅读 0赞

# 百度Utility  网络判断： #

package com.baidu.speech.utils;
    
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.content.pm.PackageManager;
    import android.net.ConnectivityManager;
    import android.net.NetworkInfo;
    import android.os.Build;
    import android.os.Build.VERSION;
    import android.text.TextUtils;
    import android.util.Log;
    
    import com.mstar.android.ethernet.EthernetManager;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.InputStream;
    import java.io.Reader;
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.util.Locale;
    
    public final class Utility
    {
        private static final int THOUSAND_DIV = 1000;
        private static final int BYTES_PER_SAMPLE_8BIT = 1;
        private static final int BYTES_PER_SAMPLE_16BIT = 2;
        private static final int BYTES_PER_SHORT = 2;
        private static int maxCpuFreq = 0;
        private static int EVR_NETWORK_TYPE_NO = 0;
        private static int EVR_NETWORK_TYPE_2G = 1;
        private static int EVR_NETWORK_TYPE_3G = 2;
        private static int EVR_NETWORK_TYPE_4G = 3;
        private static int EVR_NETWORK_TYPE_WIFI = 4;
        private static final String TAG = "Utility";
        private static ConnectivityManager mConnManager = null;
    
        static void init(Context paramContext)
        {
            if (paramContext != null) {
                mConnManager = (ConnectivityManager)paramContext.getSystemService("connectivity");
            }
        }
    
        public static int getVoiceDataSizeInShort(int paramInt1, int paramInt2, int paramInt3)
        {
            if ((paramInt3 != 2) && (paramInt3 != 3)) {
                throw new IllegalArgumentException("audio format invalid");
            }
            int i;
            if (paramInt3 == 3) {
                i = 1;
            } else {
                i = 2;
            }
            int j = paramInt1 * paramInt2 * i / 1000;
            int k = j / 2;
            return k;
        }
    
        static String generatePlatformString()
        {
            StringBuilder localStringBuilder = new StringBuilder("Android");
            localStringBuilder.append('&');
            try
            {
                localStringBuilder.append(URLEncoder.encode(Build.MODEL, "utf-8"));
                localStringBuilder.append('&');
                localStringBuilder.append(URLEncoder.encode(VERSION.RELEASE, "utf-8"));
            }
            catch (UnsupportedEncodingException localUnsupportedEncodingException)
            {
                localUnsupportedEncodingException.printStackTrace();
            }
            localStringBuilder.append('&');
            localStringBuilder.append(VERSION.SDK_INT);
            String str = localStringBuilder.toString();
            return str;
        }
    
        static int getStatusType(int paramInt)
        {
            return paramInt & 0xFFFF0000;
        }
    
        private static boolean isRunningEmulator()
        {
            return (Build.MODEL.equals("sdk")) || (Build.MODEL.equals("google_sdk"));
        }
    
        public static int getMaxCpuFreq()
        {
            try
            {
                String str = "";
                if (0 != maxCpuFreq) {
                    return maxCpuFreq;
                }
                Object localObject2;
                Object localObject1;
                Object localObject3;
                if (isRunningEmulator())
                {
                    localObject2 = new String[] { "/system/bin/cat", "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq" };
                    localObject1 = new ProcessBuilder((String[])localObject2);
                    localObject3 = ((ProcessBuilder)localObject1).start();
                    InputStream localInputStream = ((Process)localObject3).getInputStream();
                    byte[] arrayOfByte = new byte[24];
                    while (localInputStream.read(arrayOfByte) != -1) {
                        str = str + new String(arrayOfByte);
                    }
                    localInputStream.close();
                    ((Process)localObject3).destroy();
                }
                else
                {
                    localObject1 = null;
                    localObject2 = null;
                    localObject3 = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq";
                    localObject1 = new FileReader((String)localObject3);
                    localObject2 = new BufferedReader((Reader)localObject1);
                    str = ((BufferedReader)localObject2).readLine();
                    ((BufferedReader)localObject2).close();
                    ((FileReader)localObject1).close();
                }
                int i = getCpuInfo();
                if (TextUtils.isEmpty(str)) {
                    return i;
                }
                str = str.trim();
                int j = Integer.parseInt(str);
                maxCpuFreq = j >= i ? j : i;
                return maxCpuFreq;
            }
            catch (Exception localException) {}
            return 0;
        }
    
        private static int getCpuInfo()
        {
            try
            {
                String str1 = "/proc/cpuinfo";
                String str2 = "";
                String str3 = "";
                FileReader localFileReader = new FileReader(str1);
                BufferedReader localBufferedReader = new BufferedReader(localFileReader, 1024);
                while ((str2 = localBufferedReader.readLine()) != null) {
                    if (str2.indexOf("BogoMIPS") != -1)
                    {
                        String[] arrayOfString = str2.split("\\s+");
                        str3 = arrayOfString[2];
                    }
                }
                localBufferedReader.close();
                str3 = str3.trim();
                return (int)(Float.parseFloat(str3) * 1000.0F);
            }
            catch (Exception localException) {}
            return 0;
        }
    
        @SuppressLint({
      "DefaultLocale"})
        static boolean isUsingWifi()
        {
            boolean bool = false;
            if (mConnManager != null)
            {
                NetworkInfo localNetworkInfo = mConnManager.getActiveNetworkInfo();
                if (localNetworkInfo != null) {
                    bool = "wifi".equals(localNetworkInfo.getTypeName().toLowerCase());
                }
            }
            return bool;
        }
    
        public static boolean is2G(Context paramContext)
        {
            try
            {
                String str = "";
                ConnectivityManager localConnectivityManager = (ConnectivityManager)paramContext.getApplicationContext().getSystemService("connectivity");
                if (!isNetworkPerission(paramContext)) {
                    return false;
                }
                NetworkInfo localNetworkInfo = localConnectivityManager.getActiveNetworkInfo();
                if ((localNetworkInfo != null) && (localNetworkInfo.isConnectedOrConnecting()))
                {
                    str = localNetworkInfo.getTypeName().toLowerCase();
                    if (str.equals("wifi")) {
                        return false;
                    }
                    int i = localNetworkInfo.getSubtype();
                    switch (i)
                    {
                        case 1:
                        case 2:
                        case 4:
                        case 7:
                        case 11:
                        case 16:
                            return true;
                    }
                }
            }
            catch (Exception localException)
            {
                localException.printStackTrace();
            }
            return false;
        }
    
        private static boolean isNetworkPerission(Context paramContext)
        {
            try
            {
                boolean bool = 0 == paramContext.getPackageManager().checkPermission("android.permission.ACCESS_NETWORK_STATE", paramContext.getPackageName());
                return bool;
            }
            catch (Exception localException)
            {
                localException.printStackTrace();
            }
            return false;
        }
    
        static boolean isUsingWifi(Context paramContext)
        {
            try
            {
                ConnectivityManager localConnectivityManager = (ConnectivityManager)paramContext.getApplicationContext().getSystemService("connectivity");
                if (!isNetworkPerission(paramContext)) {
                    return false;
                }
                NetworkInfo localNetworkInfo = localConnectivityManager.getActiveNetworkInfo();
                if ((localNetworkInfo != null) && ("wifi".equals(localNetworkInfo.getTypeName().toLowerCase(Locale.US)))) {
                    return true;
                }
            }
            catch (Exception localException)
            {
                localException.printStackTrace();
            }
            return false;
        }
    
        @SuppressLint({
      "DefaultLocale"})
        public static int getWifiOr2gOr3G(Context paramContext)
        {
            int i = EVR_NETWORK_TYPE_NO;
            try
            {
                if (paramContext != null)
                {
                    ConnectivityManager localConnectivityManager = (ConnectivityManager)paramContext.getApplicationContext().getSystemService("connectivity");
                    if (!isNetworkPerission(paramContext)) {
                        return i;
                    }
                    NetworkInfo localNetworkInfo = localConnectivityManager.getActiveNetworkInfo();
                    if ((localNetworkInfo != null) && (localNetworkInfo.isConnectedOrConnecting()))
                    {
                        String str = localNetworkInfo.getTypeName().toLowerCase();
                        if (str.equals("wifi"))
                        {
                            i = EVR_NETWORK_TYPE_WIFI;
                        }
                        else
                        {
                            i = EVR_NETWORK_TYPE_2G;
                            int j = localNetworkInfo.getSubtype();
                            switch (j)
                            {
                                case 7:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 4:
                                    break;
                                case 2:
                                    break;
                                case 5:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 6:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 1:
                                    break;
                                case 8:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 10:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 9:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 3:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 14:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 12:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 15:
                                    i = EVR_NETWORK_TYPE_3G;
                                    break;
                                case 11:
                                    break;
                                case 13:
                                    i = EVR_NETWORK_TYPE_4G;
                            }
                        }
                    }else{
                        EthernetManager ethernetManager = EthernetManager.getInstance();
                        boolean ethConn = ethernetManager.isNetworkConnected();
                        if(ethConn){
                            i = EVR_NETWORK_TYPE_2G;
                        }
                        Log.i("MainActivityConnect","ethConn: " + ethConn);
                    }
                }
            }
            catch (Exception localException)
            {
                localException.printStackTrace();
            }
            return i;
        }
    
        public static String urlEncode(String paramString1, String paramString2)
        {
            try
            {
                if (!TextUtils.isEmpty(paramString1)) {
                    paramString1 = URLEncoder.encode(paramString1, paramString2);
                }
            }
            catch (UnsupportedEncodingException localUnsupportedEncodingException) {}
            return paramString1;
        }
    
        public static boolean checkPermission(Context paramContext, String paramString)
        {
            int i = paramContext.checkCallingOrSelfPermission(paramString);
            return i == 0;
        }
    
        public static NetworkInfo getNetworkInfo(Context paramContext)
        {
            ConnectivityManager localConnectivityManager = (ConnectivityManager)paramContext.getSystemService("connectivity");
            return localConnectivityManager.getActiveNetworkInfo();
        }
    
        public static boolean isNetworkConnected(Context paramContext)
        {
            NetworkInfo localNetworkInfo = getNetworkInfo(paramContext);
            return (localNetworkInfo != null) && (localNetworkInfo.isConnected());
        }
    
        public static boolean isWifiConnected(Context paramContext)
        {
            NetworkInfo localNetworkInfo = getNetworkInfo(paramContext);
            return (localNetworkInfo != null) && (localNetworkInfo.isConnected()) && (localNetworkInfo.getType() == 1);
        }
    
        public static String getLineNumber(Exception paramException)
        {
            StackTraceElement[] arrayOfStackTraceElement = paramException.getStackTrace();
            if ((arrayOfStackTraceElement == null) || (arrayOfStackTraceElement.length == 0)) {
                return null;
            }
            return arrayOfStackTraceElement[0].getFileName() + ":" + arrayOfStackTraceElement[0].getLineNumber();
        }
    
        public static String getFileName(Exception paramException)
        {
            StackTraceElement[] arrayOfStackTraceElement = paramException.getStackTrace();
            if ((arrayOfStackTraceElement == null) || (arrayOfStackTraceElement.length == 0)) {
                return null;
            }
            return arrayOfStackTraceElement[0].getFileName();
        }
    
        public static String fun(Exception paramException)
        {
            StackTraceElement[] arrayOfStackTraceElement = paramException.getStackTrace();
            if (arrayOfStackTraceElement == null) {
                return "";
            }
            return arrayOfStackTraceElement[0].getMethodName() + "()";
        }
    }
    
    
    /* Location:           D:\软件区\androidkiller\AndroidKiller_v1.3.1\bdasr_V3_20171108_9800a2a.jar
     * Qualified Name:     com.baidu.speech.utils.Utility
     * JD-Core Version:    0.7.0.1
     */

# 转载的获取subtype类型值问题： #

很多时候需要先判断当前用户的网络，才会继续之后的一些处理逻辑。但网络类型获取这一块，我用我自己的的手机调试时遇到一些问题，这里记录一下。

![071511597998762.png][]

一加手机一代，移动4G 网络，得到的subtype类型值为17，我查过Android 5.1的源码，它最大的值也就为16。([点击这里在线查看源码>>)][Link 1]

![071512006274876.png][]

我拿魅族的移动4G测试的结果如下：

![071512011431019.png][]

小米4，电信4G的测试结果如下：

![071512016278703.png][]

![071512049243630.png][]

魅族MX4，联通3G

![071512056895230.png][]![071512060188429.png][]

还测试了其它华为移动3G/4G的情况，就我自己的手机一加返回的值有点奇怪，之后我查了一下它的参数：[http://detail.zol.com.cn/374/373908/param.shtml][http_detail.zol.com.cn_374_373908_param.shtml]

![071512067211815.png][]

当然，其它厂商：华为、小米、魅族与上面显示的网络类型基本上是一致的。都是3G：TD-SCDMA、WCDMA等

而目前测试的情况就是仅一加返回的值为17，这会导致正常的判断出现问题，无法识别到底使用的是何种网络。而我通过logcat的日志，却很清晰的发现系统自己是能识别的

![071512074089970.png][]

最后我根据网络上提供的资料，加了一项比较特殊的判断，演变成如下的代码：

public static String GetNetworkType()
    {
         
        String strNetworkType = "";
        
        NetworkInfo networkInfo = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE).getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected())
        {
         
            if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI)
            {
         
                strNetworkType = "WIFI";
            }
            else if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE)
            {
         
                String _strSubTypeName = networkInfo.getSubtypeName();
                
                Log.e("cocos2d-x", "Network getSubtypeName : " + _strSubTypeName);
                
                // TD-SCDMA   networkType is 17
                int networkType = networkInfo.getSubtype();
                switch (networkType) {
         
                    case TelephonyManager.NETWORK_TYPE_GPRS:
                    case TelephonyManager.NETWORK_TYPE_EDGE:
                    case TelephonyManager.NETWORK_TYPE_CDMA:
                    case TelephonyManager.NETWORK_TYPE_1xRTT:
                    case TelephonyManager.NETWORK_TYPE_IDEN: //api<8 : replace by 11
                        strNetworkType = "2G";
                        break;
                    case TelephonyManager.NETWORK_TYPE_UMTS:
                    case TelephonyManager.NETWORK_TYPE_EVDO_0:
                    case TelephonyManager.NETWORK_TYPE_EVDO_A:
                    case TelephonyManager.NETWORK_TYPE_HSDPA:
                    case TelephonyManager.NETWORK_TYPE_HSUPA:
                    case TelephonyManager.NETWORK_TYPE_HSPA:
                    case TelephonyManager.NETWORK_TYPE_EVDO_B: //api<9 : replace by 14
                    case TelephonyManager.NETWORK_TYPE_EHRPD:  //api<11 : replace by 12
                    case TelephonyManager.NETWORK_TYPE_HSPAP:  //api<13 : replace by 15
                        strNetworkType = "3G";
                        break;
                    case TelephonyManager.NETWORK_TYPE_LTE:    //api<11 : replace by 13
                        strNetworkType = "4G";
                        break;
                    default:
                        // http://baike.baidu.com/item/TD-SCDMA 中国移动 联通 电信 三种3G制式
                        if (_strSubTypeName.equalsIgnoreCase("TD-SCDMA") || _strSubTypeName.equalsIgnoreCase("WCDMA") || _strSubTypeName.equalsIgnoreCase("CDMA2000")) 
                        {
         
                            strNetworkType = "3G";
                        }
                        else
                        {
         
                            strNetworkType = _strSubTypeName;
                        }
                        
                        break;
                 }
                 
                Log.e("cocos2d-x", "Network getSubtype : " + Integer.valueOf(networkType).toString());
            }
        }
        
        Log.e("cocos2d-x", "Network Type : " + strNetworkType);
        
        return strNetworkType;
    }

希望对需要的人有所帮助吧。我在网上搜索到，之前其实有人提出过类似的疑问，但是没有答案：

> ### telephony.getNetworkType() 这个方法为什么在有些手机里面获取的值API没有呢，例如16、17。这两个在 TelephonyManager这个API里面就没有 ###
> 
>  
> 
> [http://a.code4app.com/qa/q/55237d8b933bf062538b4f5d][http_a.code4app.com_qa_q_55237d8b933bf062538b4f5d]

参考链接：

[How to determine if network type is 2G, 3G or 4G][How to determine if network type is 2G_ 3G or 4G]

[Comparison of wireless data standards][]

[Android 判断用户2G/3G/4G移动数据网络][Android _2G_3G_4G]

[TD-SCDMA][]

[071511597998762.png]: /images/20220526/e3db73b5d8f241f6b9d44817f2852499.png
[Link 1]: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.0_r1/android/telephony/TelephonyManager.java#TelephonyManager
[071512006274876.png]: /images/20220526/69446aa2329e4c6583e727ab06b4c7ca.png
[071512011431019.png]: /images/20220526/b722704332614db99fcb0fb03777cff5.png
[071512016278703.png]: /images/20220526/1c085ecab8154f8db41062ef2e296f67.png
[071512049243630.png]: /images/20220526/a1cb351e1b5f4cf58da25e8e807784d2.png
[071512056895230.png]: https://images0.cnblogs.com/blog/47448/201507/071512056895230.png
[071512060188429.png]: /images/20220526/78f2f299ad954871812497b7f6b88015.png
[http_detail.zol.com.cn_374_373908_param.shtml]: http://detail.zol.com.cn/374/373908/param.shtml
[071512067211815.png]: /images/20220526/7dc26c9d81fd46dd93d2e8b955877145.png
[071512074089970.png]: /images/20220526/74cca4d3744c4c2795117455ea184f78.png
[http_a.code4app.com_qa_q_55237d8b933bf062538b4f5d]: http://a.code4app.com/qa/q/55237d8b933bf062538b4f5d
[How to determine if network type is 2G_ 3G or 4G]: http://stackoverflow.com/questions/9283765/how-to-determine-if-network-type-is-2g-3g-or-4g
[Comparison of wireless data standards]: https://en.wikipedia.org/wiki/Comparison_of_wireless_data_standards
[Android _2G_3G_4G]: http://www.binkery.com/archives/368.html#comment-241
[TD-SCDMA]: http://baike.baidu.com/item/TD-SCDMA