android手机信号强度

- 日理万妓 2023-05-22 06:40 22阅读 0赞

android手机信号强度检测   
Android开发之获取网络类型(WIFI、2G、3G、4G)和运营商名称

wifi 和 手机网络信号强度的获取不同要注意

信号单位  
android定义了2种信号单位：dBm和asu。   
信号强度单位：   
dBm（1毫瓦的分贝数）和asu（alone signal unit 独立信号单元）。

它们之间的关系是：dBm =-113+2asu，   
这是google给android手机定义的特有信号单位。例如，我的信号强度为-53dBm，则对应30asu，因为-53 = -113 + (230) 。

这是google给android手机定义的特有信号单位。而且信号强度数值越大越好，67dbm VS -90dbm ，前者信号比后者好！

中国移动的规范规定,手机接收电平>=(城市取-90dBm;乡村取-94dBm)时,则满足覆盖要求,也就是说此处无线信号强度满足覆盖要求，即接受电平>=-90dBm，就可以满足覆盖要求   
\-67dBm要比-90dBm信号要强20多个dB,那么它在打电话接通成功率和通话过程中的话音质量都会好的多(当然也包括EDGE（EDGE是一种从GSM到3G的过渡技术）/GPRS上网的速度那些 )

国内三大运营商的网络类型：  
电信   
2G CDMA   
3G CDMA2000   
4G TD-LTE，FDD-LTE

移动   
2G GSM   
3G TD-SCDMA   
4G TD-LTE，FDD-LTE

联通   
2G GSM   
3G WCDMA   
4G TD-LTE，FDD-LTE

0 —— (-55)dbm 满格(4格)信号   
(-55) —— (-70)dbm 3格信号   
(-70) —— (-85)dbm　2格信号   
(-85) —— (-100)dbm 1格信号

package android.telephony.SignalStrength

public static final int SIGNAL\_STRENGTH\_NONE\_OR\_UNKNOWN = 0;

public static final int SIGNAL\_STRENGTH\_POOR = 1;

public static final int SIGNAL\_STRENGTH\_MODERATE = 2;

public static final int SIGNAL\_STRENGTH\_GOOD = 3;

public static final int SIGNAL\_STRENGTH\_GREAT = 4;

public static final int NUM\_SIGNAL\_STRENGTH\_BINS = 5;

//无 ，低劣的 ，适度的 ，好 ，优异的  
public static final String\[\] SIGNAL\_STRENGTH\_NAMES = \{  
    "none", "poor", "moderate", "good", "great"  
\};  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
//SignalStrength: 0 -153824042 0 255 0 0 32767 -1 32767 -1 -72 -3 30 -1 0 -1 false gw|lte

@Override  
public String toString() \{  
    return ("SignalStrength:"  
            + " " + mGsmSignalStrength  
            + " " + mGsmBitErrorRate  
            + " " + mCdmaDbm  
            + " " + mCdmaEcio  
            + " " + mEvdoDbm  
            + " " + mEvdoEcio  
            + " " + mEvdoSnr  
            + " " + mLteSignalStrength  
            + " " + mLteRsrp  
            + " " + mLteRsrq  
            + " " + mLteRssnr  
            + " " + mLteCqi  
            + " " + mTdScdmaRscp  
            + " " + (isGsm ? "gsm|lte" : "cdma"));  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
//为总体信号强度检索抽象级别值: 0弱 5强

public int getLevel() \{  
    int level = 0;

if (isGsm) \{  
        level = getLteLevel();  
        if (level == SIGNAL\_STRENGTH\_NONE\_OR\_UNKNOWN) \{//0  
            level = getTdScdmaLevel();  
            if (level == SIGNAL\_STRENGTH\_NONE\_OR\_UNKNOWN) \{//0  
                level = getGsmLevel();  
            \}  
        \}  
    \} else \{  
        int cdmaLevel = getCdmaLevel();  
        int evdoLevel = getEvdoLevel();  
        if (evdoLevel == SIGNAL\_STRENGTH\_NONE\_OR\_UNKNOWN) \{//0  
            /\* We don't know evdo, use cdma \*/  
            level = cdmaLevel;  
        \} else if (cdmaLevel == SIGNAL\_STRENGTH\_NONE\_OR\_UNKNOWN) \{//0  
            /\* We don't know cdma, use evdo \*/  
            level = evdoLevel;  
        \} else \{  
            /\* We know both, use the lowest level \*/  
            level = cdmaLevel < evdoLevel ? cdmaLevel : evdoLevel;  
        \}  
    \}  
    if (DBG) log("getLevel=" + level);  
    return level;  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
Android6.0获取4G信号的信号强度（dbm）:  
TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY\_SERVICE);

PhoneStateListener MyPhoneListener = new PhoneStateListener() \{  
    @RequiresApi(api = Build.VERSION\_CODES.M)  
    public void onSignalStrengthsChanged(SignalStrength signalStrength) \{  
        int level = signalStrength.getLevel();  
        System.out.println("level==============" + level);

int asu = signalStrength.getGsmSignalStrength();  
        int dbm = -113 + 2\*asu;  
    \}  
\};

//持续监听 onresume中  
tm.listen(MyPhoneListener, PhoneStateListener.LISTEN\_SIGNAL\_STRENGTHS);

//取消监听 onpause中  
tm.listen(MyPhoneListener, PhoneStateListener.LISTEN\_NONE);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
NetUtils

public class NetUtils \{  
    public static final int NETWORK\_NONE = 0; // 没有网络连接  
    public static final int NETWORK\_WIFI = 1; // wifi连接  
    public static final int NETWORK\_2G = 2; // 2G  
    public static final int NETWORK\_3G = 3; // 3G  
    public static final int NETWORK\_4G = 4; // 4G  
    public static final int NETWORK\_MOBILE = 5; // 手机流量

/\*\*  
     \* 获取运营商名字  
     \*  
     \* @param context context  
     \* @return int  
     \*/  
    public static String getOperatorName(Context context) \{  
        /\*  
         \* getSimOperatorName()就可以直接获取到运营商的名字  
         \* 也可以使用IMSI获取，getSimOperator()，然后根据返回值判断，例如"46000"为移动  
         \* IMSI相关链接：http://baike.baidu.com/item/imsi  
         \*/  
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY\_SERVICE);  
        // getSimOperatorName就可以直接获取到运营商的名字  
        return telephonyManager.getSimOperatorName();  
    \}

/\*\*  
     \* 获取当前网络连接的类型  
     \*  
     \* @param context context  
     \* @return int  
     \*/  
    public static int getNetworkState(Context context) \{  
        ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY\_SERVICE); // 获取网络服务  
        if (null == connManager) \{ // 为空则认为无网络  
            return NETWORK\_NONE;  
        \}  
        // 获取网络类型，如果为空，返回无网络  
        NetworkInfo activeNetInfo = connManager.getActiveNetworkInfo();  
        if (activeNetInfo == null || !activeNetInfo.isAvailable()) \{  
            return NETWORK\_NONE;  
        \}  
        // 判断是否为WIFI  
        NetworkInfo wifiInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE\_WIFI);  
        if (null != wifiInfo) \{  
            NetworkInfo.State state = wifiInfo.getState();  
            if (null != state) \{  
                if (state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING) \{  
                    return NETWORK\_WIFI;  
                \}  
            \}  
        \}  
        // 若不是WIFI，则去判断是2G、3G、4G网  
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY\_SERVICE);  
        int networkType = telephonyManager.getNetworkType();  
        switch (networkType) \{  
    /\*  
       GPRS : 2G(2.5) General Packet Radia Service 114kbps  
       EDGE : 2G(2.75G) Enhanced Data Rate for GSM Evolution 384kbps  
       UMTS : 3G WCDMA 联通3G Universal Mobile Telecommunication System 完整的3G移动通信技术标准  
       CDMA : 2G 电信 Code Division Multiple Access 码分多址  
       EVDO\_0 : 3G (EVDO 全程 CDMA2000 1xEV-DO) Evolution - Data Only (Data Optimized) 153.6kps - 2.4mbps 属于3G  
       EVDO\_A : 3G 1.8mbps - 3.1mbps 属于3G过渡，3.5G  
       1xRTT : 2G CDMA2000 1xRTT (RTT - 无线电传输技术) 144kbps 2G的过渡,  
       HSDPA : 3.5G 高速下行分组接入 3.5G WCDMA High Speed Downlink Packet Access 14.4mbps  
       HSUPA : 3.5G High Speed Uplink Packet Access 高速上行链路分组接入 1.4 - 5.8 mbps  
       HSPA : 3G (分HSDPA,HSUPA) High Speed Packet Access  
       IDEN : 2G Integrated Dispatch Enhanced Networks 集成数字增强型网络 （属于2G，来自维基百科）  
       EVDO\_B : 3G EV-DO Rev.B 14.7Mbps 下行 3.5G  
       LTE : 4G Long Term Evolution FDD-LTE 和 TDD-LTE , 3G过渡，升级版 LTE Advanced 才是4G  
       EHRPD : 3G CDMA2000向LTE 4G的中间产物 Evolved High Rate Packet Data HRPD的升级  
       HSPAP : 3G HSPAP 比 HSDPA 快些  
       \*/  
            // 2G网络  
            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:  
                return NETWORK\_2G;  
            // 3G网络  
            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:  
                return NETWORK\_3G;  
            // 4G网络  
            case TelephonyManager.NETWORK\_TYPE\_LTE:  
                return NETWORK\_4G;  
            default:  
                return NETWORK\_MOBILE;  
        \}  
    \}

/\*\*  
     \* 判断网络是否连接  
     \*  
     \* @param context context  
     \* @return true/false  
     \*/  
    public static boolean isNetConnected(Context context) \{  
        ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY\_SERVICE);  
        if (connectivity != null) \{  
            NetworkInfo info = connectivity.getActiveNetworkInfo();  
            if (info != null && info.isConnected()) \{  
                if (info.getState() == NetworkInfo.State.CONNECTED) \{  
                    return true;  
                \}  
            \}  
        \}  
        return false;  
    \}

/\*\*  
     \* 判断是否wifi连接  
     \*  
     \* @param context context  
     \* @return true/false  
     \*/  
    public static synchronized boolean isWifiConnected(Context context) \{  
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY\_SERVICE);  
        if (connectivityManager != null) \{  
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();  
            if (networkInfo != null) \{  
                int networkInfoType = networkInfo.getType();  
                if (networkInfoType == ConnectivityManager.TYPE\_WIFI || networkInfoType == ConnectivityManager.TYPE\_ETHERNET) \{  
                    return networkInfo.isConnected();  
                \}  
            \}  
        \}  
        return false;  
    \}

public static int getNetworkWifiLevel(Context context) \{  
        if (!isWifiConnected(context)) \{  
            return 0;  
        \}

WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI\_SERVICE);

WifiInfo wifiInfo = wifiManager.getConnectionInfo();  
        //获得信号强度值  
        if (Build.VERSION.SDK\_INT >= Build.VERSION\_CODES.N) \{  
            int level = wifiInfo.getRssi();  
            //根据获得信号的强度发送信息  
            if (level <= 0 && level >= -50) \{//最强  
                System.out.println("level==========1===========" + level);  
                return 1;  
            \} else if (level < -50 && level >= -70) \{//较强  
                System.out.println("level===========2==========" + level);  
                return 2;  
            \} else if (level < -70 && level >= -80) \{//较弱  
                System.out.println("level==========3===========" + level);  
                return 3;  
            \} else if (level < -80 && level >= -100) \{//微弱  
                System.out.println("level==========4===========" + level);  
                return 4;  
            \} else \{  
                System.out.println("level==========5===========" + level);  
                return 5;  
            \}  
        \}

return 0;  
    \}

\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
154  
155  
156  
157  
158  
159  
160  
161  
162  
163  
164  
165  
166  
167  
168  
169  
170  
171  
172  
173  
174  
示例：  
public class MainActivity extends AppCompatActivity \{

public TextView mTextView;  
    public TelephonyManager mTelephonyManager;  
    public PhoneStatListener mListener;

/\*\*  
     \* 网络信号强度监听  
     \*/  
    @Override  
    protected void onCreate(Bundle savedInstanceState) \{  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity\_main\_wifi);

mTextView = (TextView) findViewById(R.id.textview);  
        //获取telephonyManager  
        mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY\_SERVICE);  
        //开始监听  
        mListener = new PhoneStatListener();  
        //监听信号强度  
        mTelephonyManager.listen(mListener, PhoneStatListener.LISTEN\_SIGNAL\_STRENGTHS);  
    \}

@Override  
    protected void onResume() \{  
        super.onResume();  
        mTelephonyManager.listen(mListener, PhoneStatListener.LISTEN\_SIGNAL\_STRENGTHS);  
    \}

@Override  
    protected void onPause() \{  
        super.onPause();  
        //用户不在当前页面时，停止监听  
        mTelephonyManager.listen(mListener, PhoneStatListener.LISTEN\_NONE);  
    \}

@SuppressWarnings("deprecation")  
    private class PhoneStatListener extends PhoneStateListener \{  
        //获取信号强度

@Override  
        public void onSignalStrengthChanged(int asu) \{  
            super.onSignalStrengthChanged(asu);  
        \}

@Override  
        public void onSignalStrengthsChanged(SignalStrength signalStrength) \{  
            super.onSignalStrengthsChanged(signalStrength);  
            //获取网络信号强度  
            //获取0-4的5种信号级别，越大信号越好,但是api23开始才能用  
            if (android.os.Build.VERSION.SDK\_INT >= android.os.Build.VERSION\_CODES.M) \{  
                int level = signalStrength.getLevel();  
                System.out.println("level====" + level);  
            \}  
            int cdmaDbm = signalStrength.getCdmaDbm();  
            int evdoDbm = signalStrength.getEvdoDbm();  
            System.out.println("cdmaDbm=====" + cdmaDbm);  
            System.out.println("evdoDbm=====" + evdoDbm);

int gsmSignalStrength = signalStrength.getGsmSignalStrength();  
            int dbm = -113 + 2 \* gsmSignalStrength;  
            System.out.println("dbm===========" + dbm);

//获取网络类型  
            int netWorkType = NetUtils.getNetworkState(MainActivity.this);  
            switch (netWorkType) \{  
                case NetUtils.NETWORK\_WIFI:  
                    mTextView.setText("当前网络为wifi,信号强度为：" + gsmSignalStrength);  
                    break;  
                case NetUtils.NETWORK\_2G:  
                    mTextView.setText("当前网络为2G移动网络,信号强度为：" + gsmSignalStrength);  
                    break;  
                case NetUtils.NETWORK\_3G:  
                    mTextView.setText("当前网络为3G移动网络,信号强度为：" + gsmSignalStrength);  
                    break;  
                case NetUtils.NETWORK\_4G:  
                    mTextView.setText("当前网络为4G移动网络,信号强度为：" + gsmSignalStrength);  
                    break;  
                case NetUtils.NETWORK\_NONE:  
                    mTextView.setText("当前没有网络,信号强度为：" + gsmSignalStrength);  
                    break;  
                case -1:  
                    mTextView.setText("当前网络错误,信号强度为：" + gsmSignalStrength);  
                    break;  
            \}  
        \}  
    \}

\}  
————————————————  
版权声明：本文为CSDN博主「Mars-xq」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/sinat\_31057219/article/details/81134030