当前位置：GoMCU > 未分類 > 正文

Android系统移植与调试之------->如何修改Android手机显示的4G信号强度的格子数

2018-02-28 分类：未分類 评论(0)

出處: http://blog.csdn.net/ouyang_peng/article/details/49121645

版权声明：本文为【欧阳鹏】原创文章，欢迎转载，转载请注明出处! 【http://blog.csdn.net/ouyang_peng】

           在修改显示的信号强度之前，先了解一下什么是dB，什么是dBm?

1.dB
dB是一个表征相对值的值，纯粹的比值，只表示两个量的相对大小关系，没有单位，当考虑甲的功率相比于乙功率大或小多少个dB时，

按下面的计算公式：10log（甲功率/乙功率），如果采用两者的电压比计算，要用20log（甲电压/乙电压）。)
[例] 甲功率比乙功率大一倍，那么10lg（甲功率/乙功率）=10lg2=3dB。也就是说，甲的功率比乙的功率大3 dB。

反之，如果甲的功率是乙的功率的一半，则甲的功率比乙的功率小3 dB。

2.dBm
dBm是一个表示功率绝对值的值（也可以认为是以1mW功率为基准的一个比值），计算公式为：10log（功率值/1mw）。

[例] 如果功率P为1mw，折算为dBm后为0dBm。
[例] 对于40W的功率，按dBm单位进行折算后的值应为：
10log（40W/1mw)=10log（40000）=10log4+10log10000=46dBm。
总之，dB是两个量之间的比值，表示两个量间的相对大小，而dBm则是表示功率绝对大小的值。在dB，dBm计算中，要注意基本概念，

用一个dBm减另外一个dBm时，得到的结果是dB，如：30dBm – 0dBm = 30dB。

3.手机信号强度表示

好了,那么手机上显示的数字的单位是那个呢,是dBm。当你仔细看的时候会发现这个值是负的，也就是说手机会显示比如 -67(dBm),那就说明信号很强了.

这里还说一个小知识:

中国移动的规范规定,手机接收电平>=(城市取-90dBm ;乡村取 -94dBm )时,则满足覆盖要求,也就是说此处无线信号强度满足覆盖要求。

-67dBm 要比-90dBm 信号要强20多个dB ,那么它在打电话接通成功率和通话过程中的话音质量都会好的多(当然也包括EDGE/GPRS上网的速度那些 )

所以,那个值越大信号就越好,因为那是个负值,而且在你手里的时候它永远是负值 ,如果你感

兴趣且附近有无线基站的天线的话,你也可以把你的手机尽量接近天线面板,那么值就越来越大,如果手机跟天线面板挨到一起,

那么它可能十分接近于0了(0是达不到的,这里的0的意思也不是说手机没信号了。）

在信号强度计选择工程模式，显示了很多参数，你只要看BCCHLev（控制信道电平值）它就是手机的信号强度值，单位dBm,多大的信号你的手机可以正常接听呢，BCCHLev-C1，C1也有显示数值，如：BCCHLev（-63） ，C1（34），表示你的手机在信号大于-97dBm的状况下是不会掉话的。
再来看手机发射功率要多大才合适呢，按GSM协议规定，手机发射功率是可以被基站控制的。基站通过下行SACCH信道，发出命令控制手机的发射功率级别，

每个功率级别差2dB；

GSM900 手机最大发射功率级别是5（2W=2000mw，33dBm），最小发射功率级别是19（3mw，5dBm），

DCS1800手机最大发射功率级别是0（1W，30dBm），最小发射功率级别是15（1mW，0dBm）。

当手机远离基站，或者处于无线阴影区时，基站可以命令手机发出较大功率，直至33dBm（GSM900），

以克服远距离传输或建筑物遮挡所造成的信号损耗。

强度计里的TXPower就是手机发射功率，你在拨打电话的状态下可以看出你的手机发射功率，也就是数值越大越省电，辐射越小，数值在5，

你的电话耗电大电池用不了一天，通话时别人经常听不到你的声音，你的手机经常会突然没信号，会掉话，这样你可以打投诉电话让运营商来做信号覆盖，

让你的手机信号好起来，减少辐射。

以上那么多字，只有一个核心意思。不要被你手机信号还有多少格欺骗！！！那都是手机厂商自己定义的。咱要玩专业点的，直接看信号强度dBm。
android系统查信号强度在设置—关于手机—网络里。
室内和室外的信号强度是有差距的。一般室外信号比室内好。
现在来看这个所谓的dBm，数值范围在-XX~0之间。这个数越大，信号强度越高。

-50dBm~0dBm范围内，恭喜你，你的信号已经好得很了。话说你就站在基站旁边是吧，哈
-90dBm~-60dBm，同样恭喜你，你基本不会面临打不了电话的问题。如果打不了的，找运营商吧，那是他们的问题。

G室内，DS放桌上信号强度-67dBm，23asu。作打电话状握手里，-75dBm，19asu。调整各种姿势，看到的最低是-83dBm，15asu。

这属于什么等级呢？简单说就是，信号很不错。室外没看，但肯定比这个高,
至于其他手机，可以自己上网去看，和DS的dBm值大多在一个档次。个别帖子炫耀自己大于-50dBm的，都是因为他就在基站边上。正常的范围是-90dBm~-60dBm。

 

====================================================================================

下面我们来看看手机没有修改时候的显示效果，关于手机–>状态信息–>SIM卡状态–>信号强度，就能看到手机的信号强度了。如下图所示：

1、当信号大于等于-85dBm时候，信号显示满格

2、当信号大于等于-95dBm时候，而小于-85dBm时，信号显示3格

3、当信号大于等于-105dBm时候，而小于-95dBm时，信号显示2格，不好捕捉到。

4、当信号大于等于-115dBm时候，而小于-105dBm时，信号显示1格，不好捕捉到。

5、当信号大于等于-140dBm时候，而小于-115dBm时，信号显示0格，不好捕捉到。

 

上面几个等级的相应划分的源代码在：rameworks/base/telephony/java/android/telephony/SignalStrength.java

中的getLteLevel()方法中，代码1如下：

[java] view plain copy

  1.   /**
  2.      * Get LTE as level 0..4
  3.      *
  4.      * @hide
  5.      */
  6.     public int getLteLevel() {
  7.         /*
  8.          * TS 36.214 Physical Layer Section 5.1.3 TS 36.331 RRC RSSI = received
  9.          * signal + noise RSRP = reference signal dBm RSRQ = quality of signal
  10.          * dB= Number of Resource blocksxRSRP/RSSI SNR = gain=signal/noise ratio
  11.          * = -10log P1/P2 dB
  12.          */
  13.         int rssiIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  14.         int rsrpIconLevel = –1;
  15.         int snrIconLevel = –1;
  17.         int rsrpThreshType = Resources.getSystem().getInteger(com.android.internal.R.integer.
  18.                 config_LTE_RSRP_threshold_type);
  19.         int[] threshRsrp;
  20.         if (rsrpThreshType == RSRP_THRESH_TYPE_STRICT) {
  21.             threshRsrp = RSRP_THRESH_STRICT;
  22.         } else {
  23.             threshRsrp = RSRP_THRESH_LENIENT;
  24.         }
  26.         //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  27.         if (!IS_BSP_PACKAGE) {
  28.             IServiceStateExt ssExt = getPlugInInstance();
  29.             if (ssExt != null) {
  30.                 rsrpIconLevel = ssExt.mapLteSignalLevel(mLteRsrp, mLteRssnr, mLteSignalStrength);
  31.                 //added by ouyang
  32.                 android.util.Log.e(“oyp”, “ssExt != null, rsrpIconLevel:”+ rsrpIconLevel);
  33.                 return rsrpIconLevel;
  34.             } else {
  35.                 log(“[getLteLevel] null plug-in instance”);
  36.             }
  37.         }
  38.         //modifed by ouyang [2015-10-12] start
  40. //        if (mLteRsrp > -44) {
  41. //            rsrpIconLevel = -1;
  42. //        } else if (mLteRsrp >= -85) {
  43. //            rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  44. //        } else if (mLteRsrp >= -95) {
  45. //            rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  46. //        } else if (mLteRsrp >= -105) {
  47. //            rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  48. //        } else if (mLteRsrp >= -115) {
  49. //            rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  50. //        } else if (mLteRsrp >= -140) {
  51. //            rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  52. //        }
  54.         if (mLteRsrp > –44) {
  55.             rsrpIconLevel = –1;
  56.         } else if (mLteRsrp >= –97) {
  57.             rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  58.         } else if (mLteRsrp >= –105) {
  59.             rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  60.         } else if (mLteRsrp >= –110) {
  61.             rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  62.         } else if (mLteRsrp >= –120) {
  63.             rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  64.         } else if (mLteRsrp >= –140) {
  65.             rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  66.         }
  67.         //modifed by ouyang [2015-10-12] end
  69.         //added by ouyang
  70.         android.util.Log.e(“oyp”, “getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”
  71.                         + rsrpIconLevel);
  73.         /*
  74.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  75.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  76.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  77.          * Icon Only
  78.          */
  79.         if (mLteRssnr > 300) {
  80.             snrIconLevel = –1;
  81.         } else if (mLteRssnr >= 130) {
  82.             snrIconLevel = SIGNAL_STRENGTH_GREAT;
  83.         } else if (mLteRssnr >= 45) {
  84.             snrIconLevel = SIGNAL_STRENGTH_GOOD;
  85.         } else if (mLteRssnr >= 10) {
  86.             snrIconLevel = SIGNAL_STRENGTH_MODERATE;
  87.         } else if (mLteRssnr >= –30) {
  88.             snrIconLevel = SIGNAL_STRENGTH_POOR;
  89.         } else if (mLteRssnr >= –200) {
  90.             snrIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  91.         }
  93.         //added by ouyang
  94.         android.util.Log.e(“oyp”, “getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  96.         if (DBG) log(“getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  97.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  99.         /* Choose a measurement type to use for notification */
  100.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  101.             /*
  102.              * The number of bars displayed shall be the smaller of the bars
  103.              * associated with LTE RSRP and the bars associated with the LTE
  104.              * RS_SNR
  105.              */
  107.             //added by ouyang
  108.             android.util.Log.e(“oyp”, “snrIconLevel != -1 && rsrpIconLevel != -1,”
  109.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  110.                          +(rsrpIconLevel < snrIconLevel));
  111.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  112.         }
  114.         if (snrIconLevel != –1) {
  115.             //added by ouyang
  116.             android.util.Log.e(“oyp”, “snrIconLevel != -1”);
  117.             return snrIconLevel;
  118.         }
  120.         if (rsrpIconLevel != –1) {
  121.             //added by ouyang
  122.             android.util.Log.e(“oyp”, “rsrpIconLevel != -1”);
  123.             return rsrpIconLevel;
  124.         }
  126.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  127.         if (mLteSignalStrength > 63) {
  128.             rssiIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  129.         } else if (mLteSignalStrength >= 12) {
  130.             rssiIconLevel = SIGNAL_STRENGTH_GREAT;
  131.         } else if (mLteSignalStrength >= 8) {
  132.             rssiIconLevel = SIGNAL_STRENGTH_GOOD;
  133.         } else if (mLteSignalStrength >= 5) {
  134.             rssiIconLevel = SIGNAL_STRENGTH_MODERATE;
  135.         } else if (mLteSignalStrength >= 0) {
  136.             rssiIconLevel = SIGNAL_STRENGTH_POOR;
  137.         }
  138.         //added by ouyang
  139.         android.util.Log.e(“oyp”, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  140.                     + rssiIconLevel);
  141.         if (DBG) {
  142.             log(“getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  143.                     + rssiIconLevel);
  144.         }
  146.         return rssiIconLevel;
  147.         //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC
  148.     }

可以看到未修改前，划分的几个等级是：

1.大于-85时候，等级为SIGNAL_STRENGTH_GREAT，即为4

2.大于-95时候，等级为SIGNAL_STRENGTH_GOOD，即为3

3.大于-105时候，等级为SIGNAL_STRENGTH_MODERATE，即为2

4.大于-115时候，等级为SIGNAL_STRENGTH_POOR，即为1

5.大于-140时候，等级为SIGNAL_STRENGTH_NONE_OR_UNKNOWN，即为0

6.大于-44时候，等级为-1

修改后，将上面的几个等级划分改为：

1.大于-97时候，等级为SIGNAL_STRENGTH_GREAT，即为4

2.大于-105时候，等级为SIGNAL_STRENGTH_GOOD，即为3

3.大于-110时候，等级为SIGNAL_STRENGTH_MODERATE，即为2

4.大于-120时候，等级为SIGNAL_STRENGTH_POOR，即为1

5.大于-140时候，等级为SIGNAL_STRENGTH_NONE_OR_UNKNOWN，即为0

6.大于-44时候，等级为-1

 

由于上面的，加入了MTK的修复patch，代码2如下：

[java] view plain copy

  1. //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  2.         if (!IS_BSP_PACKAGE) {
  3.             IServiceStateExt ssExt = getPlugInInstance();
  4.             if (ssExt != null) {
  5.                 rsrpIconLevel = ssExt.mapLteSignalLevel(mLteRsrp, mLteRssnr, mLteSignalStrength);
  6.                 //added by ouyang
  7.                 android.util.Log.e(“oyp”, “ssExt != null, rsrpIconLevel:”+ rsrpIconLevel);
  8.                 return rsrpIconLevel;
  9.             } else {
  10.                 log(“[getLteLevel] null plug-in instance”);
  11.             }
  12.         }

上面代码的意思是，先把这等级划分的值从加入的插件中去获取，如果获取不到再执行我上面修改的，所以要去修改

IServiceStateExt的mapLteSignalLevel(mLteRsrp, mLteRssnr, mLteSignalStrength)方法。当然如果没有这个插件的话，可以直接把我上面的这段代码2从代码1中注释即可。

由于IServiceStateExt是个接口，所以去修改它的具体实现类。通过查找源代码，找到了实现类DefaultServiceStateExt。

该类目录位于：vendor/mediatek/proprietary/frameworks/base/packages/FwkPlugin/src/com/mediatek/op/telephony/DefaultServiceStateExt.java

修改后代码如下：

[java] view plain copy

  1.   //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  2.     public int mapLteSignalLevel(int mLteRsrp, int mLteRssnr, int mLteSignalStrength) {
  3.           //added by ouyang
  4.                 android.util.Log.e(“mapLteSignalLevel”, “mapLteSignalLevel starting …….”);
  5.         /*
  6.          * TS 36.214 Physical Layer Section 5.1.3 TS 36.331 RRC RSSI = received
  7.          * signal + noise RSRP = reference signal dBm RSRQ = quality of signal
  8.          * dB= Number of Resource blocksxRSRP/RSSI SNR = gain=signal/noise ratio
  9.          * = -10log P1/P2 dB
  10.          */
  11.         int rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  12.         int rsrpIconLevel = –1;
  13.         int snrIconLevel = –1;
  15.                 //modifed by ouyang [2015-10-14] start
  16. //        if (mLteRsrp > -44) {
  17. //            rsrpIconLevel = -1;
  18. //        } else if (mLteRsrp >= -85) {
  19. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  20. //        } else if (mLteRsrp >= -95) {
  21. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  22. //        } else if (mLteRsrp >= -105) {
  23. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  24. //        } else if (mLteRsrp >= -115) {
  25. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  26. //        } else if (mLteRsrp >= -140) {
  27. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  28. //        }
  30.         if (mLteRsrp > –44) {
  31.             rsrpIconLevel = –1;
  32.         } else if (mLteRsrp >= –97) {
  33.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  34.         } else if (mLteRsrp >= –105) {
  35.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  36.         } else if (mLteRsrp >= –110) {
  37.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  38.         } else if (mLteRsrp >= –120) {
  39.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  40.         } else if (mLteRsrp >= –140) {
  41.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  42.         }
  43.                 //added by ouyang
  44.                 android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”+ rsrpIconLevel);
  45.             //modifed by ouyang [2015-10-14] end
  47.         /*
  48.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  49.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  50.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  51.          * Icon Only
  52.          */
  53.         if (mLteRssnr > 300) {
  54.             snrIconLevel = –1;
  55.         } else if (mLteRssnr >= 130) {
  56.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  57.         } else if (mLteRssnr >= 45) {
  58.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  59.         } else if (mLteRssnr >= 10) {
  60.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  61.         } else if (mLteRssnr >= –30) {
  62.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  63.         } else if (mLteRssnr >= –200) {
  64.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  65.         }
  66.         //added by ouyang
  67.             android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  68.         Log.i(TAG, “getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  69.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  71.         /* Choose a measurement type to use for notification */
  72.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  73.             /*
  74.              * The number of bars displayed shall be the smaller of the bars
  75.              * associated with LTE RSRP and the bars associated with the LTE
  76.              * RS_SNR
  77.              */
  78.              //added by ouyang
  79.                          android.util.Log.e(“mapLteSignalLevel”, “snrIconLevel != -1 && rsrpIconLevel != -1,”
  80.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  81.                          +(rsrpIconLevel < snrIconLevel));
  82.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  83.         }
  85.         if (snrIconLevel != –1) {
  86.                 //added by ouyang
  87.                         android.util.Log.e(“mapLteSignalLevel”, “snrIconLevel != -1”);
  88.             return snrIconLevel;
  89.         }
  91.         if (rsrpIconLevel != –1) {
  92.                 //added by ouyang
  93.                         android.util.Log.e(“mapLteSignalLevel”, “rsrpIconLevel != -1”);
  94.             return rsrpIconLevel;
  95.         }
  97.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  98.         if (mLteSignalStrength > 63) {
  99.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  100.         } else if (mLteSignalStrength >= 12) {
  101.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  102.         } else if (mLteSignalStrength >= 8) {
  103.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  104.         } else if (mLteSignalStrength >= 5) {
  105.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  106.         } else if (mLteSignalStrength >= 0) {
  107.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  108.         }
  109.         //added by ouyang
  110.                 android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  111.                     + rssiIconLevel);
  112.         Log.i(TAG, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  113.                 + rssiIconLevel);
  114.         return rssiIconLevel;
  115.     }
  116.     //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC

修改完代码后，make systemimage后烧录到MTK平台手机即可。

 

====================================================================================

修改后的效果图如下所示：

1、当信号大于等于-97dBm时候，信号显示满格，而修改之前需要大于-85dBm。

 

2、当信号大于等于-105dBm时候，而小于-97dBm时，信号显示少一个，而修改之前需要大于-95dBm。

 

3、当信号大于等于-110dBm时候，而小于-105dBm时，信号显示2格，不好捕捉到。

4、当信号大于等于-120dBm时候，而小于-110dBm时，信号显示1格，不好捕捉到。

5、当信号大于等于-140dBm时候，而小于-120dBm时，信号显示0格，不好捕捉到。

 

 

====================================================================================

当然，要修改电信、移动、联通的3G、2G信号也可以在这个类中去修改。

最后附上源代码   \frameworks\base\telephony\java\android\telephony\SignalStrength.java

 

[java] view plain copy

  1. /*
  2. * Copyright (C) 2014 MediaTek Inc.
  3. * Modification based on code covered by the mentioned copyright
  4. * and/or permission notice(s).
  5. */
  6. /*
  7.  * Copyright (C) 2012 The Android Open Source Project
  8.  *
  9.  * Licensed under the Apache License, Version 2.0 (the “License”);
  10.  * you may not use this file except in compliance with the License.
  11.  * You may obtain a copy of the License at
  12.  *
  13.  *      http://www.apache.org/licenses/LICENSE-2.0
  14.  *
  15.  * Unless required by applicable law or agreed to in writing, software
  16.  * distributed under the License is distributed on an “AS IS” BASIS,
  17.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18.  * See the License for the specific language governing permissions and
  19.  * limitations under the License.
  20.  */
  22. package android.telephony;
  24. import android.os.Bundle;
  25. import android.os.Parcel;
  26. import android.os.Parcelable;
  27. import android.telephony.Rlog;
  28. import android.content.res.Resources;
  29. import android.os.SystemProperties;
  31. import com.mediatek.common.MPlugin;
  32. import com.mediatek.common.telephony.IServiceStateExt;
  34. /**
  35.  * Contains phone signal strength related information.
  36.  */
  37. public class SignalStrength implements Parcelable {
  39.     private static final String LOG_TAG = “SignalStrength”;
  40.     private static final boolean DBG = false;
  42.     /** @hide */
  43.     public static final int SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0;
  44.     /** @hide */
  45.     public static final int SIGNAL_STRENGTH_POOR = 1;
  46.     /** @hide */
  47.     public static final int SIGNAL_STRENGTH_MODERATE = 2;
  48.     /** @hide */
  49.     public static final int SIGNAL_STRENGTH_GOOD = 3;
  50.     /** @hide */
  51.     public static final int SIGNAL_STRENGTH_GREAT = 4;
  52.     /** @hide */
  53.     public static final int NUM_SIGNAL_STRENGTH_BINS = 5;
  54.     /** @hide */
  55.     public static final String[] SIGNAL_STRENGTH_NAMES = {
  56.         “none”, “poor”, “moderate”, “good”, “great”
  57.     };
  59.     /** @hide */
  60.     //Use int max, as -1 is a valid value in signal strength
  61.     public static final int INVALID = 0x7FFFFFFF;
  63.     private static final int RSRP_THRESH_TYPE_STRICT = 0;
  64.     //modified by ouyang 
  65.     //private static final int[] RSRP_THRESH_STRICT = new int[] {-140, -115, -105, -95, -85, -44};
  66.       private static final int[] RSRP_THRESH_STRICT = new int[] {-140, –120, –110, –105, –97, –44};
  67.     private static final int[] RSRP_THRESH_LENIENT = new int[] {-140, –128, –118, –108, –98, –44};
  70.     private int mGsmSignalStrength; // Valid values are (0-31, 99) as defined in TS 27.007 8.5
  71.     private int mGsmBitErrorRate;   // bit error rate (0-7, 99) as defined in TS 27.007 8.5
  72.     private int mCdmaDbm;   // This value is the RSSI value
  73.     private int mCdmaEcio;  // This value is the Ec/Io
  74.     private int mEvdoDbm;   // This value is the EVDO RSSI value
  75.     private int mEvdoEcio;  // This value is the EVDO Ec/Io
  76.     private int mEvdoSnr;   // Valid values are 0-8.  8 is the highest signal to noise ratio
  77.     private int mLteSignalStrength;
  78.     private int mLteRsrp;
  79.     private int mLteRsrq;
  80.     private int mLteRssnr;
  81.     private int mLteCqi;
  82.     //MTK-START
  83.     private int mGsmRssiQdbm; // This valus is GSM 3G rssi value
  84.     private int mGsmRscpQdbm; // This valus is GSM 3G rscp value
  85.     private int mGsmEcn0Qdbm; // This valus is GSM 3G ecn0 value
  86.     private static IServiceStateExt mServiceStateExt = null;
  87.     private static final boolean IS_BSP_PACKAGE = (SystemProperties.getInt(“ro.mtk_bsp_package”, 0) == 1);
  88.     //MTK-END
  90.     private boolean isGsm; // This value is set by the ServiceStateTracker onSignalStrengthResult
  92.     /**
  93.      * Create a new SignalStrength from a intent notifier Bundle
  94.      *
  95.      * This method is used by PhoneStateIntentReceiver and maybe by
  96.      * external applications.
  97.      *
  98.      * @param m Bundle from intent notifier
  99.      * @return newly created SignalStrength
  100.      *
  101.      * @hide
  102.      */
  103.     public static SignalStrength newFromBundle(Bundle m) {
  104.         SignalStrength ret;
  105.         ret = new SignalStrength();
  106.         ret.setFromNotifierBundle(m);
  107.         return ret;
  108.     }
  110.     /**
  111.      * Empty constructor
  112.      *
  113.      * @hide
  114.      */
  115.     public SignalStrength() {
  116.         mGsmSignalStrength = 99;
  117.         mGsmBitErrorRate = –1;
  118.         mCdmaDbm = –1;
  119.         mCdmaEcio = –1;
  120.         mEvdoDbm = –1;
  121.         mEvdoEcio = –1;
  122.         mEvdoSnr = –1;
  123.         mLteSignalStrength = 99;
  124.         mLteRsrp = INVALID;
  125.         mLteRsrq = INVALID;
  126.         mLteRssnr = INVALID;
  127.         mLteCqi = INVALID;
  128.         isGsm = true;
  129.     }
  131.     /**
  132.      * This constructor is used to create SignalStrength with default
  133.      * values and set the isGsmFlag with the value passed in the input
  134.      *
  135.      * @param gsmFlag true if Gsm Phone,false if Cdma phone
  136.      * @return newly created SignalStrength
  137.      * @hide
  138.      */
  139.     public SignalStrength(boolean gsmFlag) {
  140.         mGsmSignalStrength = 99;
  141.         mGsmBitErrorRate = –1;
  142.         mCdmaDbm = –1;
  143.         mCdmaEcio = –1;
  144.         mEvdoDbm = –1;
  145.         mEvdoEcio = –1;
  146.         mEvdoSnr = –1;
  147.         mLteSignalStrength = 99;
  148.         mLteRsrp = INVALID;
  149.         mLteRsrq = INVALID;
  150.         mLteRssnr = INVALID;
  151.         mLteCqi = INVALID;
  152.         isGsm = gsmFlag;
  153.     }
  155.     /**
  156.      * Constructor
  157.      *
  158.      * @hide
  159.      */
  160.     public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate,
  161.             int cdmaDbm, int cdmaEcio,
  162.             int evdoDbm, int evdoEcio, int evdoSnr,
  163.             int lteSignalStrength, int lteRsrp, int lteRsrq, int lteRssnr, int lteCqi,
  164.             boolean gsmFlag) {
  165.         initialize(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio,
  166.                 evdoDbm, evdoEcio, evdoSnr, lteSignalStrength, lteRsrp,
  167.                 lteRsrq, lteRssnr, lteCqi, gsmFlag);
  168.     }
  172.     //MTK-START
  173.     /**
  174.      * Constructor
  175.      *
  176.      * @hide
  177.      */
  178.     public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate,
  179.             int cdmaDbm, int cdmaEcio,
  180.             int evdoDbm, int evdoEcio, int evdoSnr,
  181.             int lteSignalStrength, int lteRsrp, int lteRsrq, int lteRssnr, int lteCqi,
  182.             boolean gsmFlag, int gsmRssiQdbm, int gsmRscpQdbm, int gsmEcn0Qdbm) {
  183.         initialize(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio,
  184.                 evdoDbm, evdoEcio, evdoSnr, lteSignalStrength, lteRsrp,
  185.                 lteRsrq, lteRssnr, lteCqi, gsmFlag);
  186.         mGsmRssiQdbm = gsmRssiQdbm;
  187.         mGsmRscpQdbm = gsmRscpQdbm;
  188.         mGsmEcn0Qdbm = gsmEcn0Qdbm;
  189.     }
  190.     //MTK-END
  192.     /**
  193.      * Constructor
  194.      *
  195.      * @hide
  196.      */
  197.     public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate,
  198.             int cdmaDbm, int cdmaEcio,
  199.             int evdoDbm, int evdoEcio, int evdoSnr,
  200.             boolean gsmFlag) {
  201.         initialize(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio,
  202.                 evdoDbm, evdoEcio, evdoSnr, 99, INVALID,
  203.                 INVALID, INVALID, INVALID, gsmFlag);
  204.     }
  206.     /**
  207.      * Copy constructors
  208.      *
  209.      * @param s Source SignalStrength
  210.      *
  211.      * @hide
  212.      */
  213.     public SignalStrength(SignalStrength s) {
  214.         copyFrom(s);
  215.     }
  217.     /**
  218.      * Initialize gsm/cdma values, sets lte values to defaults.
  219.      *
  220.      * @param gsmSignalStrength
  221.      * @param gsmBitErrorRate
  222.      * @param cdmaDbm
  223.      * @param cdmaEcio
  224.      * @param evdoDbm
  225.      * @param evdoEcio
  226.      * @param evdoSnr
  227.      * @param gsm
  228.      *
  229.      * @hide
  230.      */
  231.     public void initialize(int gsmSignalStrength, int gsmBitErrorRate,
  232.             int cdmaDbm, int cdmaEcio,
  233.             int evdoDbm, int evdoEcio, int evdoSnr,
  234.             boolean gsm) {
  235.         initialize(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio,
  236.                 evdoDbm, evdoEcio, evdoSnr, 99, INVALID,
  237.                 INVALID, INVALID, INVALID, gsm);
  238.     }
  240.     /**
  241.      * Initialize all the values
  242.      *
  243.      * @param gsmSignalStrength
  244.      * @param gsmBitErrorRate
  245.      * @param cdmaDbm
  246.      * @param cdmaEcio
  247.      * @param evdoDbm
  248.      * @param evdoEcio
  249.      * @param evdoSnr
  250.      * @param lteSignalStrength
  251.      * @param lteRsrp
  252.      * @param lteRsrq
  253.      * @param lteRssnr
  254.      * @param lteCqi
  255.      * @param gsm
  256.      *
  257.      * @hide
  258.      */
  259.     public void initialize(int gsmSignalStrength, int gsmBitErrorRate,
  260.             int cdmaDbm, int cdmaEcio,
  261.             int evdoDbm, int evdoEcio, int evdoSnr,
  262.             int lteSignalStrength, int lteRsrp, int lteRsrq, int lteRssnr, int lteCqi,
  263.             boolean gsm) {
  264.         mGsmSignalStrength = gsmSignalStrength;
  265.         mGsmBitErrorRate = gsmBitErrorRate;
  266.         mCdmaDbm = cdmaDbm;
  267.         mCdmaEcio = cdmaEcio;
  268.         mEvdoDbm = evdoDbm;
  269.         mEvdoEcio = evdoEcio;
  270.         mEvdoSnr = evdoSnr;
  271.         mLteSignalStrength = lteSignalStrength;
  272.         mLteRsrp = lteRsrp;
  273.         mLteRsrq = lteRsrq;
  274.         mLteRssnr = lteRssnr;
  275.         mLteCqi = lteCqi;
  276.         isGsm = gsm;
  277.         if (DBG) {
  278.             log(“initialize: “ + toString());
  279.         }
  280.     }
  282.     private static IServiceStateExt getPlugInInstance() {
  283.         log(“SignalStrength get plugin”);
  284.         if (!IS_BSP_PACKAGE) {
  285.             if (mServiceStateExt == null) {
  286.                 try {
  287.                     mServiceStateExt = MPlugin.createInstance(IServiceStateExt.class.getName());
  288.                 } catch (RuntimeException e) {
  289.                     log(“Get plugin fail”);
  290.                     mServiceStateExt = null;
  291.                     e.printStackTrace();
  292.                 }
  293.             }
  294.         } else {
  295.             log(“BSP package should not use plug in”);
  296.         }
  298.         return mServiceStateExt;
  299.     }
  301.     /**
  302.      * @hide
  303.      */
  304.     protected void copyFrom(SignalStrength s) {
  305.         mGsmSignalStrength = s.mGsmSignalStrength;
  306.         mGsmBitErrorRate = s.mGsmBitErrorRate;
  307.         mCdmaDbm = s.mCdmaDbm;
  308.         mCdmaEcio = s.mCdmaEcio;
  309.         mEvdoDbm = s.mEvdoDbm;
  310.         mEvdoEcio = s.mEvdoEcio;
  311.         mEvdoSnr = s.mEvdoSnr;
  312.         mLteSignalStrength = s.mLteSignalStrength;
  313.         mLteRsrp = s.mLteRsrp;
  314.         mLteRsrq = s.mLteRsrq;
  315.         mLteRssnr = s.mLteRssnr;
  316.         mLteCqi = s.mLteCqi;
  317.         isGsm = s.isGsm;
  318.         mGsmRssiQdbm = s.mGsmRssiQdbm;
  319.         mGsmRscpQdbm = s.mGsmRscpQdbm;
  320.         mGsmEcn0Qdbm = s.mGsmEcn0Qdbm;
  321.     }
  323.     /**
  324.      * Construct a SignalStrength object from the given parcel.
  325.      *
  326.      * @hide
  327.      */
  328.     public SignalStrength(Parcel in) {
  329.         if (DBG) {
  330.             log(“Size of signalstrength parcel:” + in.dataSize());
  331.         }
  333.         mGsmSignalStrength = in.readInt();
  334.         mGsmBitErrorRate = in.readInt();
  335.         mCdmaDbm = in.readInt();
  336.         mCdmaEcio = in.readInt();
  337.         mEvdoDbm = in.readInt();
  338.         mEvdoEcio = in.readInt();
  339.         mEvdoSnr = in.readInt();
  340.         mLteSignalStrength = in.readInt();
  341.         mLteRsrp = in.readInt();
  342.         mLteRsrq = in.readInt();
  343.         mLteRssnr = in.readInt();
  344.         mLteCqi = in.readInt();
  345.         isGsm = (in.readInt() != 0);
  347.         //MTK-START [ALPS00516994]
  348.         mGsmRssiQdbm = in.readInt();
  349.         mGsmRscpQdbm = in.readInt();
  350.         mGsmEcn0Qdbm = in.readInt();
  351.         //MTK-END [ALPS00516994]
  353.     }
  355.     /**
  356.      * Make a SignalStrength object from the given parcel as passed up by
  357.      * the ril which does not have isGsm. isGsm will be changed by ServiceStateTracker
  358.      * so the default is a don’t care.
  359.      *
  360.      * @hide
  361.      */
  362.     public static SignalStrength makeSignalStrengthFromRilParcel(Parcel in) {
  363.         if (DBG) {
  364.             log(“Size of signalstrength parcel:” + in.dataSize());
  365.         }
  367.         SignalStrength ss = new SignalStrength();
  368.         ss.mGsmSignalStrength = in.readInt();
  369.         ss.mGsmBitErrorRate = in.readInt();
  370.         ss.mCdmaDbm = in.readInt();
  371.         ss.mCdmaEcio = in.readInt();
  372.         ss.mEvdoDbm = in.readInt();
  373.         ss.mEvdoEcio = in.readInt();
  374.         ss.mEvdoSnr = in.readInt();
  375.         ss.mLteSignalStrength = in.readInt();
  376.         ss.mLteRsrp = in.readInt();
  377.         ss.mLteRsrq = in.readInt();
  378.         ss.mLteRssnr = in.readInt();
  379.         ss.mLteCqi = in.readInt();
  381.         ss.isGsm = (in.readInt() != 0);
  383.         //MTK-START [ALPS00516994]
  384.         ss.mGsmRssiQdbm = in.readInt();
  385.         ss.mGsmRscpQdbm = in.readInt();
  386.         ss.mGsmEcn0Qdbm = in.readInt();
  387.         //MTK-END [ALPS00516994]
  389.         return ss;
  390.     }
  392.     /**
  393.      * {@link Parcelable#writeToParcel}
  394.      */
  395.     public void writeToParcel(Parcel out, int flags) {
  396.         out.writeInt(mGsmSignalStrength);
  397.         out.writeInt(mGsmBitErrorRate);
  398.         out.writeInt(mCdmaDbm);
  399.         out.writeInt(mCdmaEcio);
  400.         out.writeInt(mEvdoDbm);
  401.         out.writeInt(mEvdoEcio);
  402.         out.writeInt(mEvdoSnr);
  403.         out.writeInt(mLteSignalStrength);
  404.         out.writeInt(mLteRsrp);
  405.         out.writeInt(mLteRsrq);
  406.         out.writeInt(mLteRssnr);
  407.         out.writeInt(mLteCqi);
  408.         out.writeInt(isGsm ? 1 : 0);
  410.         //MTK-START [ALPS00516994]
  411.         out.writeInt(mGsmRssiQdbm);
  412.         out.writeInt(mGsmRscpQdbm);
  413.         out.writeInt(mGsmEcn0Qdbm);
  414.         //MTK-END [ALPS00516994]
  416.     }
  418.     /**
  419.      * {@link Parcelable#describeContents}
  420.      */
  421.     public int describeContents() {
  422.         return 0;
  423.     }
  425.     /**
  426.      * {@link Parcelable.Creator}
  427.      *
  428.      * @hide
  429.      */
  430.     public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
  431.         public SignalStrength createFromParcel(Parcel in) {
  432.             return new SignalStrength(in);
  433.         }
  435.         public SignalStrength[] newArray(int size) {
  436.             return new SignalStrength[size];
  437.         }
  438.     };
  440.     /**
  441.      * Validate the individual signal strength fields as per the range
  442.      * specified in ril.h
  443.      * Set to invalid any field that is not in the valid range
  444.      * Cdma, evdo, lte rsrp & rsrq values are sign converted
  445.      * when received from ril interface
  446.      *
  447.      * @return
  448.      *      Valid values for all signalstrength fields
  449.      * @hide
  450.      */
  451.     public void validateInput() {
  452.         if (DBG) {
  453.             log(“Signal before validate=” + this);
  454.         }
  455.         // TS 27.007 8.5
  456.         mGsmSignalStrength = mGsmSignalStrength >= 0 ? mGsmSignalStrength : 99;
  457.         // BER no change;
  459.         mCdmaDbm = mCdmaDbm > 0 ? -mCdmaDbm : –120;
  460.         mCdmaEcio = (mCdmaEcio > 0) ? -mCdmaEcio : –160;
  462.         mEvdoDbm = (mEvdoDbm > 0) ? -mEvdoDbm : –120;
  463.         mEvdoEcio = (mEvdoEcio >= 0) ? -mEvdoEcio : –1;
  464.         mEvdoSnr = ((mEvdoSnr > 0) && (mEvdoSnr <= 8)) ? mEvdoSnr : –1;
  466.         // TS 36.214 Physical Layer Section 5.1.3, TS 36.331 RRC
  467.         mLteSignalStrength = (mLteSignalStrength >= 0) ? mLteSignalStrength : 99;
  469.         mLteRsrp = ((mLteRsrp >= 44) && (mLteRsrp <= 140)) ? -mLteRsrp : SignalStrength.INVALID;
  470.         mLteRsrq = ((mLteRsrq >= 3) && (mLteRsrq <= 20)) ? -mLteRsrq : SignalStrength.INVALID;
  471.         mLteRssnr = ((mLteRssnr >= –200) && (mLteRssnr <= 300)) ? mLteRssnr
  472.                 : SignalStrength.INVALID;
  474.         // Cqi no change
  475.         if (DBG) {
  476.             log(“Signal after validate=” + this);
  477.         }
  478.     }
  480.     /**
  481.      * @param true – Gsm, Lte phones
  482.      *        false – Cdma phones
  483.      *
  484.      * Used by voice phone to set the isGsm
  485.      *        flag
  486.      * @hide
  487.      */
  488.     public void setGsm(boolean gsmFlag) {
  489.         isGsm = gsmFlag;
  490.     }
  492.     /**
  493.      * Get the GSM Signal Strength, valid values are (0-31, 99) as defined in TS
  494.      * 27.007 8.5
  495.      */
  496.     public int getGsmSignalStrength() {
  497.         return this.mGsmSignalStrength;
  498.     }
  500.     /**
  501.      * Get the GSM bit error rate (0-7, 99) as defined in TS 27.007 8.5
  502.      */
  503.     public int getGsmBitErrorRate() {
  504.         return this.mGsmBitErrorRate;
  505.     }
  507.     /**
  508.      * Get the CDMA RSSI value in dBm
  509.      */
  510.     public int getCdmaDbm() {
  511.         return this.mCdmaDbm;
  512.     }
  514.     /**
  515.      * Get the CDMA Ec/Io value in dB*10
  516.      */
  517.     public int getCdmaEcio() {
  518.         return this.mCdmaEcio;
  519.     }
  521.     /**
  522.      * Get the EVDO RSSI value in dBm
  523.      */
  524.     public int getEvdoDbm() {
  525.         return this.mEvdoDbm;
  526.     }
  528.     /**
  529.      * Get the EVDO Ec/Io value in dB*10
  530.      */
  531.     public int getEvdoEcio() {
  532.         return this.mEvdoEcio;
  533.     }
  535.     /**
  536.      * Get the signal to noise ratio. Valid values are 0-8. 8 is the highest.
  537.      */
  538.     public int getEvdoSnr() {
  539.         return this.mEvdoSnr;
  540.     }
  542.     /** @hide */
  543.     public int getLteSignalStrength() {
  544.         return mLteSignalStrength;
  545.     }
  547.     /** @hide */
  548.     public int getLteRsrp() {
  549.         return mLteRsrp;
  550.     }
  552.     /** @hide */
  553.     public int getLteRsrq() {
  554.         return mLteRsrq;
  555.     }
  557.     /** @hide */
  558.     public int getLteRssnr() {
  559.         return mLteRssnr;
  560.     }
  562.     /** @hide */
  563.     public int getLteCqi() {
  564.         return mLteCqi;
  565.     }
  567.     /**
  568.      * Get signal level as an int from 0..4
  569.      *
  570.      * @hide
  571.      */
  572.     public int getLevel() {
  573.         int level;
  575.         if (isGsm) {
  576.             level = getLteLevel();
  577.             //MTE-START [ALPS01200757]
  578.             //if (level == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) {
  579.             if (!isCampOnLte()) {
  580.             //MTE-END [ALPS01200757]
  581.                 level = getGsmLevel();
  582.             }
  583.         } else {
  584.             int cdmaLevel = getCdmaLevel();
  585.             int evdoLevel = getEvdoLevel();
  586.             if (evdoLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) {
  587.                 /* We don’t know evdo, use cdma */
  588.                 level = cdmaLevel;
  589.             } else if (cdmaLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) {
  590.                 /* We don’t know cdma, use evdo */
  591.                 level = evdoLevel;
  592.             } else {
  593.                 /* We know both, use the lowest level */
  594.                 level = cdmaLevel < evdoLevel ? cdmaLevel : evdoLevel;
  595.             }
  596.         }
  597.         if (DBG) {
  598.             log(“getLevel=” + level);
  599.         }
  600.         return level;
  601.     }
  603.     /**
  604.      * Get the signal level as an asu value between 0..31, 99 is unknown
  605.      *
  606.      * @hide
  607.      */
  608.     public int getAsuLevel() {
  609.         int asuLevel;
  610.         if (isGsm) {
  611.             //MTE-START [ALPS01200757]
  612.             //if (getLteLevel() == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) {
  613.             if (!isCampOnLte()) {
  614.             //MTE-END [ALPS01200757]
  615.                 asuLevel = getGsmAsuLevel();
  616.             } else {
  617.                 asuLevel = getLteAsuLevel();
  618.             }
  619.         } else {
  620.             int cdmaAsuLevel = getCdmaAsuLevel();
  621.             int evdoAsuLevel = getEvdoAsuLevel();
  622.             if (evdoAsuLevel == 0) {
  623.                 /* We don’t know evdo use, cdma */
  624.                 asuLevel = cdmaAsuLevel;
  625.             } else if (cdmaAsuLevel == 0) {
  626.                 /* We don’t know cdma use, evdo */
  627.                 asuLevel = evdoAsuLevel;
  628.             } else {
  629.                 /* We know both, use the lowest level */
  630.                 asuLevel = cdmaAsuLevel < evdoAsuLevel ? cdmaAsuLevel : evdoAsuLevel;
  631.             }
  632.         }
  633.         if (DBG) {
  634.             log(“getAsuLevel=” + asuLevel);
  635.         }
  636.         return asuLevel;
  637.     }
  639.     /**
  640.      * Get the signal strength as dBm
  641.      *
  642.      * @hide
  643.      */
  644.     public int getDbm() {
  645.         int dBm;
  647.         if(isGsm()) {
  648.             dBm = getLteDbm();
  649.             //MTE-START [ALPS01200757]
  650.             //if (dBm == INVALID) {
  651.             if (!isCampOnLte()) {
  652.             //MTE-END [ALPS01200757]
  653.                 dBm = getGsmDbm();
  654.             }
  655.         } else {
  656.             int cdmaDbm = getCdmaDbm();
  657.             int evdoDbm = getEvdoDbm();
  659.             return (evdoDbm == –120 || evdoDbm == –113) ? cdmaDbm
  660.                     : ((cdmaDbm == –120 || cdmaDbm == –113) ? evdoDbm
  661.                     : (cdmaDbm < evdoDbm ? cdmaDbm : evdoDbm));
  662.         }
  663.         if (DBG) {
  664.             log(“getDbm=” + dBm);
  665.         }
  666.         return dBm;
  667.     }
  669.     /**
  670.      * Get Gsm signal strength as dBm
  671.      *
  672.      * @hide
  673.      */
  674.     public int getGsmDbm() {
  675.         int dBm;
  677.         int gsmSignalStrength = getGsmSignalStrength();
  678.         int asu = (gsmSignalStrength == 99 ? –1 : gsmSignalStrength);
  679.         if (asu != –1) {
  680.             if (!IS_BSP_PACKAGE) {
  681.                 IServiceStateExt ssExt = getPlugInInstance();
  682.                 if (ssExt != null) {
  683.                     dBm = ssExt.mapGsmSignalDbm(mGsmRscpQdbm, asu);
  684.                 } else {
  685.                     log(“[getGsmDbm] null plug-in instance”);
  686.                 }
  687.             }
  689.             log(“mapGsmSignalDbm() mGsmRscpQdbm=” + mGsmRscpQdbm + ” asu=” + asu);
  691.             if (mGsmRscpQdbm < 0) {
  692.                 dBm = mGsmRscpQdbm / 4; //Return raw value for 3G Network
  693.             } else {
  694.                 dBm = –113 + (2 * asu);
  695.             }
  696.         } else {
  697.             dBm = –1;
  698.         }
  699.         if (DBG) {
  700.             log(“getGsmDbm=” + dBm);
  701.         }
  702.         return dBm;
  703.     }
  705.     /**
  706.      * Get gsm as level 0..4
  707.      *
  708.      * @hide
  709.      */
  710.     public int getGsmLevel() {
  711.         int level;
  713.         // ASU ranges from 0 to 31 – TS 27.007 Sec 8.5
  714.         // asu = 0 (-113dB or less) is very weak
  715.         // signal, its better to show 0 bars to the user in such cases.
  716.         // asu = 99 is a special case, where the signal strength is unknown.
  717.         int asu = getGsmSignalStrength();
  719.         if (!IS_BSP_PACKAGE) {
  720.             IServiceStateExt ssExt = getPlugInInstance();
  721.             if (ssExt != null) {
  722.                 level = ssExt.mapGsmSignalLevel(asu, mGsmRscpQdbm);
  723.                 return level;
  724.             } else {
  725.                 log(“[getGsmLevel] null plug-in instance”);
  726.             }
  727.         }
  729.         // [ALPS01055164] — START , for 3G network
  730.         if (mGsmRscpQdbm < 0) {
  731.             // 3G network
  732.             if (asu <= 5 || asu == 99) {
  733.                 level = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  734.             } else if (asu >= 15) {
  735.                 level = SignalStrength.SIGNAL_STRENGTH_GREAT;
  736.             } else if (asu >= 12) {
  737.                 level = SignalStrength.SIGNAL_STRENGTH_GOOD;
  738.             } else if (asu >= 9) {
  739.                 level = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  740.             } else {
  741.                 level = SignalStrength.SIGNAL_STRENGTH_POOR;
  742.             }
  743.         // [ALPS01055164] — END
  744.         } else {
  745.             // 2G network
  746.             if (asu <= 2 || asu == 99) {
  747.                 level = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  748.             } else if (asu >= 12) {
  749.                 level = SIGNAL_STRENGTH_GREAT;
  750.             } else if (asu >= 8) {
  751.                 level = SIGNAL_STRENGTH_GOOD;
  752.             } else if (asu >= 5) {
  753.                 level = SIGNAL_STRENGTH_MODERATE;
  754.             } else {
  755.                 level = SIGNAL_STRENGTH_POOR;
  756.             }
  757.         }
  759.         if (DBG) {
  760.             log(“getGsmLevel=” + level);
  761.         }
  762.         return level;
  763.     }
  765.     /**
  766.      * Get the gsm signal level as an asu value between 0..31, 99 is unknown
  767.      *
  768.      * @hide
  769.      */
  770.     public int getGsmAsuLevel() {
  771.         // ASU ranges from 0 to 31 – TS 27.007 Sec 8.5
  772.         // asu = 0 (-113dB or less) is very weak
  773.         // signal, its better to show 0 bars to the user in such cases.
  774.         // asu = 99 is a special case, where the signal strength is unknown.
  775.         int level = getGsmSignalStrength();
  776.         if (DBG) {
  777.             log(“getGsmAsuLevel=” + level);
  778.         }
  779.         return level;
  780.     }
  782.     /**
  783.      * Get cdma as level 0..4
  784.      *
  785.      * @hide
  786.      */
  787.     public int getCdmaLevel() {
  788.         final int cdmaDbm = getCdmaDbm();
  789.         final int cdmaEcio = getCdmaEcio();
  790.         int levelDbm;
  791.         int levelEcio;
  793.         if (cdmaDbm >= –75) levelDbm = SIGNAL_STRENGTH_GREAT;
  794.         else if (cdmaDbm >= –85) levelDbm = SIGNAL_STRENGTH_GOOD;
  795.         else if (cdmaDbm >= –95) levelDbm = SIGNAL_STRENGTH_MODERATE;
  796.         else if (cdmaDbm >= –100) levelDbm = SIGNAL_STRENGTH_POOR;
  797.         else levelDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  799.         // Ec/Io are in dB*10
  800.         if (cdmaEcio >= –90) levelEcio = SIGNAL_STRENGTH_GREAT;
  801.         else if (cdmaEcio >= –110) levelEcio = SIGNAL_STRENGTH_GOOD;
  802.         else if (cdmaEcio >= –130) levelEcio = SIGNAL_STRENGTH_MODERATE;
  803.         else if (cdmaEcio >= –150) levelEcio = SIGNAL_STRENGTH_POOR;
  804.         else levelEcio = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  806.         int level = (levelDbm < levelEcio) ? levelDbm : levelEcio;
  807.         /// M: [C2K] Only use dbm as to calculate level. @{
  808.         if (isC2KSupport()) {
  809.             level = levelDbm;
  810.         }
  811.         /// M: [C2K] Only use dbm as to calculate level. @}
  812.         if (DBG) {
  813.             log(“getCdmaLevel=” + level);
  814.         }
  815.         return level;
  816.     }
  818.     /**
  819.      * Get the cdma signal level as an asu value between 0..31, 99 is unknown
  820.      *
  821.      * @hide
  822.      */
  823.     public int getCdmaAsuLevel() {
  824.         final int cdmaDbm = getCdmaDbm();
  825.         final int cdmaEcio = getCdmaEcio();
  826.         int cdmaAsuLevel;
  827.         int ecioAsuLevel;
  829.         if (cdmaDbm >= –75) cdmaAsuLevel = 16;
  830.         else if (cdmaDbm >= –82) cdmaAsuLevel = 8;
  831.         else if (cdmaDbm >= –90) cdmaAsuLevel = 4;
  832.         else if (cdmaDbm >= –95) cdmaAsuLevel = 2;
  833.         else if (cdmaDbm >= –100) cdmaAsuLevel = 1;
  834.         else cdmaAsuLevel = 99;
  836.         // Ec/Io are in dB*10
  837.         if (cdmaEcio >= –90) ecioAsuLevel = 16;
  838.         else if (cdmaEcio >= –100) ecioAsuLevel = 8;
  839.         else if (cdmaEcio >= –115) ecioAsuLevel = 4;
  840.         else if (cdmaEcio >= –130) ecioAsuLevel = 2;
  841.         else if (cdmaEcio >= –150) ecioAsuLevel = 1;
  842.         else ecioAsuLevel = 99;
  844.         int level = (cdmaAsuLevel < ecioAsuLevel) ? cdmaAsuLevel : ecioAsuLevel;
  845.         if (DBG) {
  846.             log(“getCdmaAsuLevel=” + level);
  847.         }
  848.         return level;
  849.     }
  851.     /**
  852.      * Get Evdo as level 0..4
  853.      *
  854.      * @hide
  855.      */
  856.     public int getEvdoLevel() {
  857.         int evdoDbm = getEvdoDbm();
  858.         int evdoSnr = getEvdoSnr();
  859.         int levelEvdoDbm;
  860.         int levelEvdoSnr;
  862.         if (evdoDbm >= –65) levelEvdoDbm = SIGNAL_STRENGTH_GREAT;
  863.         else if (evdoDbm >= –75) levelEvdoDbm = SIGNAL_STRENGTH_GOOD;
  864.         else if (evdoDbm >= –90) levelEvdoDbm = SIGNAL_STRENGTH_MODERATE;
  865.         else if (evdoDbm >= –105) levelEvdoDbm = SIGNAL_STRENGTH_POOR;
  866.         else levelEvdoDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  868.         if (evdoSnr >= 7) levelEvdoSnr = SIGNAL_STRENGTH_GREAT;
  869.         else if (evdoSnr >= 5) levelEvdoSnr = SIGNAL_STRENGTH_GOOD;
  870.         else if (evdoSnr >= 3) levelEvdoSnr = SIGNAL_STRENGTH_MODERATE;
  871.         else if (evdoSnr >= 1) levelEvdoSnr = SIGNAL_STRENGTH_POOR;
  872.         else levelEvdoSnr = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  874.         int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr;
  875.         if (DBG) {
  876.             log(“getEvdoLevel=” + level);
  877.         }
  878.         return level;
  879.     }
  881.     /**
  882.      * Get the evdo signal level as an asu value between 0..31, 99 is unknown
  883.      *
  884.      * @hide
  885.      */
  886.     public int getEvdoAsuLevel() {
  887.         int evdoDbm = getEvdoDbm();
  888.         int evdoSnr = getEvdoSnr();
  889.         int levelEvdoDbm;
  890.         int levelEvdoSnr;
  892.         if (evdoDbm >= –65) levelEvdoDbm = 16;
  893.         else if (evdoDbm >= –75) levelEvdoDbm = 8;
  894.         else if (evdoDbm >= –85) levelEvdoDbm = 4;
  895.         else if (evdoDbm >= –95) levelEvdoDbm = 2;
  896.         else if (evdoDbm >= –105) levelEvdoDbm = 1;
  897.         else levelEvdoDbm = 99;
  899.         if (evdoSnr >= 7) levelEvdoSnr = 16;
  900.         else if (evdoSnr >= 6) levelEvdoSnr = 8;
  901.         else if (evdoSnr >= 5) levelEvdoSnr = 4;
  902.         else if (evdoSnr >= 3) levelEvdoSnr = 2;
  903.         else if (evdoSnr >= 1) levelEvdoSnr = 1;
  904.         else levelEvdoSnr = 99;
  906.         int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr;
  907.         if (DBG) {
  908.             log(“getEvdoAsuLevel=” + level);
  909.         }
  910.         return level;
  911.     }
  913.     /**
  914.      * Get LTE as dBm
  915.      *
  916.      * @hide
  917.      */
  918.     public int getLteDbm() {
  919.         return mLteRsrp;
  920.     }
  922.     /**
  923.      * Get LTE as level 0..4
  924.      *
  925.      * @hide
  926.      */
  927.     public int getLteLevel() {
  928.         /*
  929.          * TS 36.214 Physical Layer Section 5.1.3 TS 36.331 RRC RSSI = received
  930.          * signal + noise RSRP = reference signal dBm RSRQ = quality of signal
  931.          * dB= Number of Resource blocksxRSRP/RSSI SNR = gain=signal/noise ratio
  932.          * = -10log P1/P2 dB
  933.          */
  934.         int rssiIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  935.         int rsrpIconLevel = –1;
  936.         int snrIconLevel = –1;
  938.         int rsrpThreshType = Resources.getSystem().getInteger(com.android.internal.R.integer.
  939.                 config_LTE_RSRP_threshold_type);
  940.         int[] threshRsrp;
  941.         if (rsrpThreshType == RSRP_THRESH_TYPE_STRICT) {
  942.             threshRsrp = RSRP_THRESH_STRICT;
  943.         } else {
  944.             threshRsrp = RSRP_THRESH_LENIENT;
  945.         }
  947.         //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  948.         if (!IS_BSP_PACKAGE) {
  949.             IServiceStateExt ssExt = getPlugInInstance();
  950.             if (ssExt != null) {
  951.                 rsrpIconLevel = ssExt.mapLteSignalLevel(mLteRsrp, mLteRssnr, mLteSignalStrength);
  952.                 //added by ouyang
  953.                 android.util.Log.e(“oyp”, “ssExt != null, rsrpIconLevel:”+ rsrpIconLevel);
  954.                 return rsrpIconLevel;
  955.             } else {
  956.                 log(“[getLteLevel] null plug-in instance”);
  957.             }
  958.         }
  959.         //modifed by ouyang [2015-10-12] start
  961. //        if (mLteRsrp > -44) {
  962. //            rsrpIconLevel = -1;
  963. //        } else if (mLteRsrp >= -85) {
  964. //            rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  965. //        } else if (mLteRsrp >= -95) {
  966. //            rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  967. //        } else if (mLteRsrp >= -105) {
  968. //            rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  969. //        } else if (mLteRsrp >= -115) {
  970. //            rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  971. //        } else if (mLteRsrp >= -140) {
  972. //            rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  973. //        }
  975.         if (mLteRsrp > –44) {
  976.             rsrpIconLevel = –1;
  977.         } else if (mLteRsrp >= –97) {
  978.             rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  979.         } else if (mLteRsrp >= –105) {
  980.             rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  981.         } else if (mLteRsrp >= –110) {
  982.             rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  983.         } else if (mLteRsrp >= –120) {
  984.             rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  985.         } else if (mLteRsrp >= –140) {
  986.             rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  987.         }
  988.         //modifed by ouyang [2015-10-12] end
  990.         //added by ouyang
  991.         android.util.Log.e(“oyp”, “getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”
  992.                         + rsrpIconLevel);
  994.         /*
  995.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  996.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  997.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  998.          * Icon Only
  999.          */
  1000.         if (mLteRssnr > 300) {
  1001.             snrIconLevel = –1;
  1002.         } else if (mLteRssnr >= 130) {
  1003.             snrIconLevel = SIGNAL_STRENGTH_GREAT;
  1004.         } else if (mLteRssnr >= 45) {
  1005.             snrIconLevel = SIGNAL_STRENGTH_GOOD;
  1006.         } else if (mLteRssnr >= 10) {
  1007.             snrIconLevel = SIGNAL_STRENGTH_MODERATE;
  1008.         } else if (mLteRssnr >= –30) {
  1009.             snrIconLevel = SIGNAL_STRENGTH_POOR;
  1010.         } else if (mLteRssnr >= –200) {
  1011.             snrIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  1012.         }
  1014.         //added by ouyang
  1015.         android.util.Log.e(“oyp”, “getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  1017.         if (DBG) log(“getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  1018.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  1020.         /* Choose a measurement type to use for notification */
  1021.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  1022.             /*
  1023.              * The number of bars displayed shall be the smaller of the bars
  1024.              * associated with LTE RSRP and the bars associated with the LTE
  1025.              * RS_SNR
  1026.              */
  1028.             //added by ouyang
  1029.             android.util.Log.e(“oyp”, “snrIconLevel != -1 && rsrpIconLevel != -1,”
  1030.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  1031.                          +(rsrpIconLevel < snrIconLevel));
  1032.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  1033.         }
  1035.         if (snrIconLevel != –1) {
  1036.             //added by ouyang
  1037.             android.util.Log.e(“oyp”, “snrIconLevel != -1”);
  1038.             return snrIconLevel;
  1039.         }
  1041.         if (rsrpIconLevel != –1) {
  1042.             //added by ouyang
  1043.             android.util.Log.e(“oyp”, “rsrpIconLevel != -1”);
  1044.             return rsrpIconLevel;
  1045.         }
  1047.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  1048.         if (mLteSignalStrength > 63) {
  1049.             rssiIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  1050.         } else if (mLteSignalStrength >= 12) {
  1051.             rssiIconLevel = SIGNAL_STRENGTH_GREAT;
  1052.         } else if (mLteSignalStrength >= 8) {
  1053.             rssiIconLevel = SIGNAL_STRENGTH_GOOD;
  1054.         } else if (mLteSignalStrength >= 5) {
  1055.             rssiIconLevel = SIGNAL_STRENGTH_MODERATE;
  1056.         } else if (mLteSignalStrength >= 0) {
  1057.             rssiIconLevel = SIGNAL_STRENGTH_POOR;
  1058.         }
  1059.         //added by ouyang
  1060.         android.util.Log.e(“oyp”, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  1061.                     + rssiIconLevel);
  1062.         if (DBG) {
  1063.             log(“getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  1064.                     + rssiIconLevel);
  1065.         }
  1067.         return rssiIconLevel;
  1068.         //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC
  1069.     }
  1070.     /**
  1071.      * Get the LTE signal level as an asu value between 0..97, 99 is unknown
  1072.      * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69
  1073.      *
  1074.      * @hide
  1075.      */
  1076.     public int getLteAsuLevel() {
  1077.         int lteAsuLevel = 99;
  1078.         int lteDbm = getLteDbm();
  1079.         /*
  1080.          * 3GPP 27.007 (Ver 10.3.0) Sec 8.69
  1081.          * 0   -140 dBm or less
  1082.          * 1   -139 dBm
  1083.          * 2…96  -138… -44 dBm
  1084.          * 97  -43 dBm or greater
  1085.          * 255 not known or not detectable
  1086.          */
  1087.         /*
  1088.          * validateInput will always give a valid range between -140 t0 -44 as
  1089.          * per ril.h. so RSRP >= -43 & <-140 will fall under asu level 255
  1090.          * and not 97 or 0
  1091.          */
  1092.         if (lteDbm == SignalStrength.INVALID) {
  1093.             lteAsuLevel = 255;
  1094.         } else {
  1095.             lteAsuLevel = lteDbm + 140;
  1096.         }
  1097.         if (DBG) {
  1098.             log(“Lte Asu level: “ + lteAsuLevel);
  1099.         }
  1100.         return lteAsuLevel;
  1101.     }
  1103.     /**
  1104.      * @return true if this is for GSM
  1105.      */
  1106.     public boolean isGsm() {
  1107.         return this.isGsm;
  1108.     }
  1110.     /**
  1111.      * @return hash code
  1112.      */
  1113.     @Override
  1114.     public int hashCode() {
  1115.         int primeNum = 31;
  1116.         return ((mGsmSignalStrength * primeNum)
  1117.                 + (mGsmBitErrorRate * primeNum)
  1118.                 + (mCdmaDbm * primeNum) + (mCdmaEcio * primeNum)
  1119.                 + (mEvdoDbm * primeNum) + (mEvdoEcio * primeNum) + (mEvdoSnr * primeNum)
  1120.                 + (mLteSignalStrength * primeNum) + (mLteRsrp * primeNum)
  1121.                 + (mLteRsrq * primeNum) + (mLteRssnr * primeNum) + (mLteCqi * primeNum)
  1122.                 + (isGsm ? 1 : 0));
  1123.     }
  1125.     /**
  1126.      * @return true if the signal strengths are the same
  1127.      */
  1128.     @Override
  1129.     public boolean equals (Object o) {
  1130.         SignalStrength s;
  1132.         try {
  1133.             s = (SignalStrength) o;
  1134.         } catch (ClassCastException ex) {
  1135.             return false;
  1136.         }
  1138.         if (o == null) {
  1139.             return false;
  1140.         }
  1142.         return (mGsmSignalStrength == s.mGsmSignalStrength
  1143.                 && mGsmBitErrorRate == s.mGsmBitErrorRate
  1144.                 && mCdmaDbm == s.mCdmaDbm
  1145.                 && mCdmaEcio == s.mCdmaEcio
  1146.                 && mEvdoDbm == s.mEvdoDbm
  1147.                 && mEvdoEcio == s.mEvdoEcio
  1148.                 && mEvdoSnr == s.mEvdoSnr
  1149.                 && mLteSignalStrength == s.mLteSignalStrength
  1150.                 && mLteRsrp == s.mLteRsrp
  1151.                 && mLteRsrq == s.mLteRsrq
  1152.                 && mLteRssnr == s.mLteRssnr
  1153.                 && mLteCqi == s.mLteCqi
  1154.                 && isGsm == s.isGsm
  1155.                 && mGsmRscpQdbm == s.mGsmRscpQdbm); /* ALPS00334516 */
  1156.     }
  1158.     /**
  1159.      * @return string representation.
  1160.      */
  1161.     @Override
  1162.     public String toString() {
  1163.         return (“SignalStrength:”
  1164.                 + ” “ + mGsmSignalStrength
  1165.                 + ” “ + mGsmBitErrorRate
  1166.                 + ” “ + mCdmaDbm
  1167.                 + ” “ + mCdmaEcio
  1168.                 + ” “ + mEvdoDbm
  1169.                 + ” “ + mEvdoEcio
  1170.                 + ” “ + mEvdoSnr
  1171.                 + ” “ + mLteSignalStrength
  1172.                 + ” “ + mLteRsrp
  1173.                 + ” “ + mLteRsrq
  1174.                 + ” “ + mLteRssnr
  1175.                 + ” “ + mLteCqi
  1176.                 + ” “ + (isGsm ? “gsm|lte” : “cdma”)
  1177.                 + ” “ + mGsmRssiQdbm
  1178.                 + ” “ + mGsmRscpQdbm
  1179.                 + ” “ + mGsmEcn0Qdbm);
  1180.     }
  1182.     /**
  1183.      * Set SignalStrength based on intent notifier map
  1184.      *
  1185.      * @param m intent notifier map
  1186.      * @hide
  1187.      */
  1188.     private void setFromNotifierBundle(Bundle m) {
  1189.         mGsmSignalStrength = m.getInt(“GsmSignalStrength”);
  1190.         mGsmBitErrorRate = m.getInt(“GsmBitErrorRate”);
  1191.         mCdmaDbm = m.getInt(“CdmaDbm”);
  1192.         mCdmaEcio = m.getInt(“CdmaEcio”);
  1193.         mEvdoDbm = m.getInt(“EvdoDbm”);
  1194.         mEvdoEcio = m.getInt(“EvdoEcio”);
  1195.         mEvdoSnr = m.getInt(“EvdoSnr”);
  1196.         mLteSignalStrength = m.getInt(“LteSignalStrength”);
  1197.         mLteRsrp = m.getInt(“LteRsrp”);
  1198.         mLteRsrq = m.getInt(“LteRsrq”);
  1199.         mLteRssnr = m.getInt(“LteRssnr”);
  1200.         mLteCqi = m.getInt(“LteCqi”);
  1201.         isGsm = m.getBoolean(“isGsm”);
  1203.         mGsmRssiQdbm = m.getInt(“RssiQdbm”);
  1204.         mGsmRscpQdbm = m.getInt(“RscpQdbm”);
  1205.         mGsmEcn0Qdbm = m.getInt(“Ecn0Qdbm”);
  1206.     }
  1208.     /**
  1209.      * Set intent notifier Bundle based on SignalStrength
  1210.      *
  1211.      * @param m intent notifier Bundle
  1212.      * @hide
  1213.      */
  1214.     public void fillInNotifierBundle(Bundle m) {
  1215.         m.putInt(“GsmSignalStrength”, mGsmSignalStrength);
  1216.         m.putInt(“GsmBitErrorRate”, mGsmBitErrorRate);
  1217.         m.putInt(“CdmaDbm”, mCdmaDbm);
  1218.         m.putInt(“CdmaEcio”, mCdmaEcio);
  1219.         m.putInt(“EvdoDbm”, mEvdoDbm);
  1220.         m.putInt(“EvdoEcio”, mEvdoEcio);
  1221.         m.putInt(“EvdoSnr”, mEvdoSnr);
  1222.         m.putInt(“LteSignalStrength”, mLteSignalStrength);
  1223.         m.putInt(“LteRsrp”, mLteRsrp);
  1224.         m.putInt(“LteRsrq”, mLteRsrq);
  1225.         m.putInt(“LteRssnr”, mLteRssnr);
  1226.         m.putInt(“LteCqi”, mLteCqi);
  1227.         m.putBoolean(“isGsm”, Boolean.valueOf(isGsm));
  1229.         m.putInt(“RssiQdbm”, mGsmRssiQdbm);
  1230.         m.putInt(“RscpQdbm”, mGsmRscpQdbm);
  1231.         m.putInt(“Ecn0Qdbm”, mGsmEcn0Qdbm);
  1232.     }
  1234.     /**
  1235.      * log
  1236.      */
  1237.     private static void log(String s) {
  1238.         Rlog.w(LOG_TAG, s);
  1239.     }
  1241.     /**
  1242.      * Get the GSM 3G rssi value
  1243.      *
  1244.      * @hide
  1245.      */
  1246.     public int getGsmRssiQdbm() {
  1247.         return this.mGsmRssiQdbm;
  1248.     }
  1250.     /**
  1251.      * Get the GSM 3G rscp value
  1252.      *
  1253.      * @hide
  1254.      */
  1255.     public int getGsmRscpQdbm() {
  1256.         return this.mGsmRscpQdbm;
  1257.     }
  1259.     /**
  1260.      * Get the GSM 3G ecn0 value
  1261.      *
  1262.      * @hide
  1263.      */
  1264.     public int getGsmEcn0Qdbm() {
  1265.         return this.mGsmEcn0Qdbm;
  1266.     }
  1268.     /**
  1269.      * Get the GSM Signal Strength Dbm value
  1270.      *
  1271.      * @hide
  1272.      * @internal
  1273.      */
  1274.     public int getGsmSignalStrengthDbm() {
  1275.         int dBm = –1;
  1276.         int gsmSignalStrength = this.mGsmSignalStrength;
  1277.         int asu = (gsmSignalStrength == 99 ? –1 : gsmSignalStrength);
  1279.         if (asu != –1) {
  1280.             if (!IS_BSP_PACKAGE) {
  1281.                 IServiceStateExt ssExt = getPlugInInstance();
  1282.                 if (ssExt != null) {
  1283.                     dBm = ssExt.mapGsmSignalDbm(mGsmRscpQdbm, asu);
  1284.                     return dBm;
  1285.                  } else {
  1286.                     log(“[getGsmSignalStrengthDbm] null plug-in instance”);
  1287.                 }
  1288.             }
  1289.             dBm = –113 + (2 * asu);
  1290.         }
  1291.         return dBm;
  1292.     }
  1294.     /**
  1295.      * Test whether two objects hold the same data values or both are null
  1296.      *
  1297.      * @param a first obj
  1298.      * @param b second obj
  1299.      * @return true if two objects equal or both are null
  1300.      * @hide
  1301.      */
  1302.     private static boolean equalsHandlesNulls(Object a, Object b) {
  1303.         return (a == null) ? (b == null) : a.equals(b);
  1304.     }
  1306.     //MTE-START [ALPS01200757]
  1307.     /**
  1308.      * check if current network is LTE
  1309.      *
  1310.      * if we camp on LTE network then the least fiele of +ECSQ will be .
  1311.      * It will be set to mEvdoDbm in getSingnalStrength() of ril_nw.c
  1312.      * And change value to “-7” by SingnalStrength.validateInput() when GsmSST receive signal update.
  1313.      * @return true when camp on LTE network
  1314.      *
  1315.      * @hide
  1316.      * @internal
  1317.      */
  1318.     private boolean isCampOnLte() {
  1319.         return (isGsm() && (mEvdoDbm == –7)) ;
  1320.     }
  1321.     //MTE-END [ALPS01200757]
  1323.     ///M:For svlte signal strength. @{
  1324.     /**
  1325.      * Set the GSM Signal Strength.
  1326.      *
  1327.      * @param gsmSignalStrength The GSM GSM Signal Strength
  1328.      * @hide
  1329.      */
  1330.     public void setGsmSignalStrength(int gsmSignalStrength) {
  1331.         mGsmSignalStrength = gsmSignalStrength;
  1332.     }
  1334.     /**
  1335.      * Set the GSM Bit Error Rate.
  1336.      *
  1337.      * @param gsmBitErrorRate the GSM Bit Error Rate
  1338.      * @hide
  1339.      */
  1340.     public void setGsmBitErrorRate(int gsmBitErrorRate) {
  1341.         mGsmBitErrorRate = gsmBitErrorRate;
  1342.     }
  1344.     /**
  1345.      * Set the CDMA Dbm.
  1346.      *
  1347.      * @param cdmaDbm the CDMA Dbm
  1348.      * @hide
  1349.      */
  1350.     public void setCdmaDbm(int cdmaDbm) {
  1351.         mCdmaDbm = cdmaDbm;
  1352.     }
  1354.     /**
  1355.      * Set the CDMA Ecio.
  1356.      *
  1357.      * @param cdmaEcio the CDMA Ecio
  1358.      * @hide
  1359.      */
  1360.     public void setCdmaEcio(int cdmaEcio) {
  1361.         mCdmaEcio = cdmaEcio;
  1362.     }
  1364.     /**
  1365.      * Set the EVDO Dbm.
  1366.      *
  1367.      * @param evdoDbm the EVDO Dbm
  1368.      * @hide
  1369.      */
  1370.     public void setEvdoDbm(int evdoDbm) {
  1371.         mEvdoDbm = evdoDbm;
  1372.     }
  1374.     /**
  1375.      * Set the EVDO Ecio.
  1376.      *
  1377.      * @param evdoEcio the EVDO Ecio
  1378.      * @hide
  1379.      */
  1380.     public void setEvdoEcio(int evdoEcio) {
  1381.         mEvdoEcio = evdoEcio;
  1382.     }
  1384.     /**
  1385.      * Set the EVDO Snr.
  1386.      *
  1387.      * @param evdoSnr the EVDO Snr
  1388.      * @hide
  1389.      */
  1390.     public void setEvdoSnr(int evdoSnr) {
  1391.         mEvdoSnr = evdoSnr;
  1392.     }
  1394.     /**
  1395.      * Set the LTE Signal Strength.
  1396.      *
  1397.      * @param lteSignalStrength the LTE Signal Strength
  1398.      * @hide
  1399.      */
  1400.     public void setLteSignalStrength(int lteSignalStrength) {
  1401.         mLteSignalStrength = lteSignalStrength;
  1402.     }
  1404.     /**
  1405.      * Set the LTE Rsrp.
  1406.      *
  1407.      * @param lteRsrp the LTE Rsrp
  1408.      * @hide
  1409.      */
  1410.     public void setLteRsrp(int lteRsrp) {
  1411.         mLteRsrp = lteRsrp;
  1412.     }
  1414.     /**
  1415.      * Set the LTE Rsrq.
  1416.      *
  1417.      * @param lteRsrq the LTE Rsrq
  1418.      * @hide
  1419.      */
  1420.     public void setLteRsrq(int lteRsrq) {
  1421.         mLteRsrq = lteRsrq;
  1422.     }
  1424.     /**
  1425.      * Set the LTE Rssnr.
  1426.      *
  1427.      * @param lteRssnr the LTE Rssnr
  1428.      * @hide
  1429.      */
  1430.     public void setLteRssnr(int lteRssnr) {
  1431.         mLteRssnr = lteRssnr;
  1432.     }
  1434.     /**
  1435.      * Set the LTE Cqi.
  1436.      *
  1437.      * @param lteCqi the LTE Cqi
  1438.      * @hide
  1439.      */
  1440.     public void setLteCqi(int lteCqi) {
  1441.         mLteCqi = lteCqi;
  1442.     }
  1444.     /**
  1445.      * Set the GSM rssi Qdbm.
  1446.      *
  1447.      * @param gsmRssiQdbm the GSM rssi Qdbm
  1448.      * @hide
  1449.      */
  1450.     public void setGsmRssiQdbm(int gsmRssiQdbm) {
  1451.         mGsmRssiQdbm = gsmRssiQdbm;
  1452.     }
  1454.     /**
  1455.      * Get the GSM Rscp Qdbm.
  1456.      *
  1457.      * @param gsmRscpQdbm the GSM Rscp Qdbm
  1458.      * @hide
  1459.      */
  1460.     public void setGsmRscpQdbm(int gsmRscpQdbm) {
  1461.         mGsmRscpQdbm = gsmRscpQdbm;
  1462.     }
  1464.     /**
  1465.      * Set the Gsm Ecn0 Qdbm.
  1466.      *
  1467.      * @param gsmEcn0Qdbm the Gsm Ecn0 Qdbm
  1468.      * @hide
  1469.      */
  1470.     public void setGsmEcn0Qdbm(int gsmEcn0Qdbm) {
  1471.         mGsmEcn0Qdbm = gsmEcn0Qdbm;
  1472.     }
  1474.     /**
  1475.      * Check if C2K feature is supported.
  1476.      * @return True if C2K feature is supported.
  1477.      */
  1478.     private static boolean isC2KSupport() {
  1479.         return SystemProperties.get(“ro.mtk_c2k_support”).equals(“1”);
  1480.     }
  1482.     /// M: [C2K][SVLTE] Added API for SignalStrength. @}
  1483. }

 

 

====================================================================================

vendor/mediatek/proprietary/frameworks/base/packages/FwkPlugin/src/com/mediatek/op/telephony/DefaultServiceStateExt.java代码如下：

 

[java] view plain copy

  1. /* Copyright Statement:
  2.  *
  3.  * This software/firmware and related documentation (“MediaTek Software”) are
  4.  * protected under relevant copyright laws. The information contained herein is
  5.  * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
  6.  * the prior written permission of MediaTek inc. and/or its licensors, any
  7.  * reproduction, modification, use or disclosure of MediaTek Software, and
  8.  * information contained herein, in whole or in part, shall be strictly
  9.  * prohibited.
  10.  *
  11.  * MediaTek Inc. (C) 2010. All rights reserved.
  12.  *
  13.  * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  14.  * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS (“MEDIATEK SOFTWARE”)
  15.  * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
  16.  * ON AN “AS-IS” BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
  17.  * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  18.  * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  19.  * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
  20.  * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
  21.  * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
  22.  * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
  23.  * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER’S SOLE RESPONSIBILITY TO
  24.  * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
  25.  * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
  26.  * RELEASES MADE TO RECEIVER’S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  27.  * STANDARD OR OPEN FORUM. RECEIVER’S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK’S
  28.  * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
  29.  * RELEASED HEREUNDER WILL BE, AT MEDIATEK’S OPTION, TO REVISE OR REPLACE THE
  30.  * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
  31.  * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  32.  *
  33.  * The following software/firmware and/or related documentation (“MediaTek
  34.  * Software”) have been modified by MediaTek Inc. All revisions are subject to
  35.  * any receiver’s applicable license agreements with MediaTek Inc.
  36.  */
  38. package com.mediatek.op.telephony;
  40. import android.content.Context;
  41. import android.content.res.Resources;
  42. import android.os.SystemProperties;
  43. import android.telephony.ServiceState;
  44. import android.telephony.SignalStrength;
  45. import android.util.Log;
  47. import com.mediatek.common.PluginImpl;
  48. import com.mediatek.common.telephony.IServiceStateExt;
  49. import android.provider.Settings;
  50. import android.telephony.SubscriptionManager;
  51. import com.android.internal.telephony.Phone;
  52. import com.android.internal.telephony.PhoneConstants;
  53. import com.android.internal.telephony.PhoneBase;
  54. import com.android.internal.telephony.PhoneFactory;
  55. import com.android.internal.telephony.PhoneProxy;
  57. import java.util.Map;
  59. @PluginImpl(interfaceName=“com.mediatek.common.telephony.IServiceStateExt”)
  60. public class DefaultServiceStateExt implements IServiceStateExt {
  61.     static final String TAG = “GSM”;
  62.     private Context mContext;
  64.     public DefaultServiceStateExt() {
  65.     }
  67.     public DefaultServiceStateExt(Context context) {
  68.         mContext = context;
  69.     }
  71.     public String onUpdateSpnDisplay(String plmn, ServiceState ss, int phoneId) {
  72.         /* ALPS00362903 */
  73.         if (SystemProperties.get(“ro.mtk_network_type_always_on”).equals(“1”)) {
  74.             // for LTE
  75.             if (ss.getRilVoiceRadioTechnology() == ServiceState.RIL_RADIO_TECHNOLOGY_LTE
  76.                 && plmn != Resources.getSystem().getText(com.android.internal.R.string.
  77.                         lockscreen_carrier_default).toString()) {
  78.                 plmn = plmn + ” 4G”;
  79.             } else if (ss.getRilVoiceRadioTechnology() > ServiceState.RIL_RADIO_TECHNOLOGY_EDGE
  80.                 /* ALPS00492303 */
  81.                 //if (radioTechnology > 2 && plmn != null){
  82.                     && plmn != Resources.getSystem().getText(com.android.internal.R.string.
  83.                             lockscreen_carrier_default).toString()) {
  84.                 plmn = plmn + ” 3G”;
  85.             }
  86.         }
  88.         return plmn;
  89.     }
  91.     public boolean isImeiLocked() {
  92.         return false;
  93.     }
  95.     public boolean isBroadcastEmmrrsPsResume(int value) {
  96.         return false;
  97.     }
  99.     public boolean needEMMRRS() {
  100.         return false;
  101.     }
  103.     public boolean needSpnRuleShowPlmnOnly() {
  104.         //[ALPS01679495]-start: don’t show SPN for CTA case
  105.         if (SystemProperties.get(“ro.mtk_cta_support”).equals(“1”)) {
  106.             return true;
  107.         }
  108.         //[ALPS01679495]-end
  109.         return false;
  110.     }
  112.     public boolean needBrodcastAcmt(int errorType, int errorCause) {
  113.         return false;
  114.     }
  116.     public boolean needRejectCauseNotification(int cause) {
  117.         return false;
  118.     }
  120.     public boolean needIgnoredState(int state, int newState, int cause) {
  121.         if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 2)) {
  122.             /* Don’t update for searching state, there shall be final registered state
  123.                update later */
  124.             Log.i(TAG, “set dontUpdateNetworkStateFlag for searching state”);
  125.             return true;
  126.         }
  128.         /* -1 means modem didn’t provide  information. */
  129.         if (cause != –1) {
  130.             // [ALPS01384143] need to check if previous state is IN_SERVICE for invalid sim
  131.             if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 3) && (cause != 0)) {
  132.             //if((newState == 3) && (cause != 0)){
  133.                 /* This is likely temporarily network failure, don’t update for better UX */
  134.                 Log.i(TAG, “set dontUpdateNetworkStateFlag for REG_DENIED with cause”);
  135.                 return true;
  136.             //[ALPS01976914] – start
  137.             } else if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 0) && (cause != 0)) {
  138.                 Log.i(TAG, “set dontUpdateNetworkStateFlag for NOT_REG_AND_NOT_SEARCH with cause”);
  139.                 return true;
  140.             }
  141.             //[ALPS01976914] – end
  142.         }
  144.         Log.i(TAG, “clear dontUpdateNetworkStateFlag”);
  146.         return false;
  147.     }
  149.     public boolean ignoreDomesticRoaming() {
  150.         return false;
  151.     }
  153.     public int mapGsmSignalLevel(int asu, int gsmRscpQdbm) {
  154.         int level;
  155.         // [ALPS01055164] — START , for 3G network
  156.         if (gsmRscpQdbm < 0) {
  157.             // 3G network
  158.             if (asu <= 5 || asu == 99) {
  159.                 level = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  160.             } else if (asu >= 15) {
  161.                 level = SignalStrength.SIGNAL_STRENGTH_GREAT;
  162.             } else if (asu >= 12) {
  163.                 level = SignalStrength.SIGNAL_STRENGTH_GOOD;
  164.             } else if (asu >= 9) {
  165.                 level = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  166.             } else {
  167.                 level = SignalStrength.SIGNAL_STRENGTH_POOR;
  168.             }
  169.         // [ALPS01055164] — END
  170.         } else {
  171.             // 2G network
  172.             if (asu <= 2 || asu == 99) {
  173.                 level = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  174.             } else if (asu >= 12) {
  175.                 level = SignalStrength.SIGNAL_STRENGTH_GREAT;
  176.             } else if (asu >= 8) {
  177.                 level = SignalStrength.SIGNAL_STRENGTH_GOOD;
  178.             } else if (asu >= 5) {
  179.                 level = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  180.             } else {
  181.                 level = SignalStrength.SIGNAL_STRENGTH_POOR;
  182.             }
  183.         }
  184.         return level;
  185.     }
  187.     //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  188.     public int mapLteSignalLevel(int mLteRsrp, int mLteRssnr, int mLteSignalStrength) {
  189.           //added by ouyang
  190.                 android.util.Log.e(“mapLteSignalLevel”, “mapLteSignalLevel starting …….”);
  191.         /*
  192.          * TS 36.214 Physical Layer Section 5.1.3 TS 36.331 RRC RSSI = received
  193.          * signal + noise RSRP = reference signal dBm RSRQ = quality of signal
  194.          * dB= Number of Resource blocksxRSRP/RSSI SNR = gain=signal/noise ratio
  195.          * = -10log P1/P2 dB
  196.          */
  197.         int rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  198.         int rsrpIconLevel = –1;
  199.         int snrIconLevel = –1;
  201.                 //modifed by ouyang [2015-10-14] start
  202. //        if (mLteRsrp > -44) {
  203. //            rsrpIconLevel = -1;
  204. //        } else if (mLteRsrp >= -85) {
  205. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  206. //        } else if (mLteRsrp >= -95) {
  207. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  208. //        } else if (mLteRsrp >= -105) {
  209. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  210. //        } else if (mLteRsrp >= -115) {
  211. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  212. //        } else if (mLteRsrp >= -140) {
  213. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  214. //        }
  216.         if (mLteRsrp > –44) {
  217.             rsrpIconLevel = –1;
  218.         } else if (mLteRsrp >= –97) {
  219.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  220.         } else if (mLteRsrp >= –105) {
  221.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  222.         } else if (mLteRsrp >= –110) {
  223.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  224.         } else if (mLteRsrp >= –120) {
  225.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  226.         } else if (mLteRsrp >= –140) {
  227.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  228.         }
  229.                 //added by ouyang
  230.                 android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”+ rsrpIconLevel);
  231.             //modifed by ouyang [2015-10-14] end
  233.         /*
  234.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  235.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  236.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  237.          * Icon Only
  238.          */
  239.         if (mLteRssnr > 300) {
  240.             snrIconLevel = –1;
  241.         } else if (mLteRssnr >= 130) {
  242.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  243.         } else if (mLteRssnr >= 45) {
  244.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  245.         } else if (mLteRssnr >= 10) {
  246.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  247.         } else if (mLteRssnr >= –30) {
  248.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  249.         } else if (mLteRssnr >= –200) {
  250.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  251.         }
  252.         //added by ouyang
  253.             android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  254.         Log.i(TAG, “getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  255.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  257.         /* Choose a measurement type to use for notification */
  258.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  259.             /*
  260.              * The number of bars displayed shall be the smaller of the bars
  261.              * associated with LTE RSRP and the bars associated with the LTE
  262.              * RS_SNR
  263.              */
  264.              //added by ouyang
  265.                          android.util.Log.e(“mapLteSignalLevel”, “snrIconLevel != -1 && rsrpIconLevel != -1,”
  266.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  267.                          +(rsrpIconLevel < snrIconLevel));
  268.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  269.         }
  271.         if (snrIconLevel != –1) {
  272.                 //added by ouyang
  273.                         android.util.Log.e(“mapLteSignalLevel”, “snrIconLevel != -1”);
  274.             return snrIconLevel;
  275.         }
  277.         if (rsrpIconLevel != –1) {
  278.                 //added by ouyang
  279.                         android.util.Log.e(“mapLteSignalLevel”, “rsrpIconLevel != -1”);
  280.             return rsrpIconLevel;
  281.         }
  283.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  284.         if (mLteSignalStrength > 63) {
  285.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  286.         } else if (mLteSignalStrength >= 12) {
  287.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  288.         } else if (mLteSignalStrength >= 8) {
  289.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  290.         } else if (mLteSignalStrength >= 5) {
  291.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  292.         } else if (mLteSignalStrength >= 0) {
  293.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  294.         }
  295.         //added by ouyang
  296.                 android.util.Log.e(“mapLteSignalLevel”, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  297.                     + rssiIconLevel);
  298.         Log.i(TAG, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  299.                 + rssiIconLevel);
  300.         return rssiIconLevel;
  301.     }
  302.     //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC
  304.     public int mapGsmSignalDbm(int gsmRscpQdbm, int asu) {
  305.         int dBm;
  306.         Log.d(TAG, “mapGsmSignalDbm() gsmRscpQdbm=” + gsmRscpQdbm + ” asu=” + asu);
  307.         if (gsmRscpQdbm < 0) {
  308.             dBm = gsmRscpQdbm / 4; //Return raw value for 3G Network
  309.         } else {
  310.             dBm = –113 + (2 * asu);
  311.         }
  312.         return dBm;
  313.     }
  315.     public void log(String text) {
  316.         Log.d(TAG, text);
  317.     }
  319.     public Map loadSpnOverrides() {
  320.         return null;
  321.     }
  323.     public boolean allowSpnDisplayed() {
  324.         return true;
  325.     }
  327.     public boolean supportEccForEachSIM() {
  328.         return false;
  329.     }
  331.     public void updateOplmn(Context context, Object ci) {
  332.     }
  334.     //[ALPS01558804] MTK-START: send notification for using some spcial icc card
  335.     public boolean needIccCardTypeNotification(String iccCardType) {
  336.         return false;
  337.     }
  339.     //[ALPS01862093]-Start: not supprot auto switch rat for SIM card type
  340.     //du to UI spec. define chagend
  341.     public int needAutoSwitchRatMode(int phoneId, String nwPlmn) {
  342.         return –1;
  343.     }
  344.     //re-mark
  345.     /*
  346.     //[ALPS01577029] To support auto switch rat mode
  347.     public int needAutoSwitchRatMode(int phoneId,String nwPlmn) {
  348.         int simType = -1; // 0: SIM , 1: USIM
  349.         int currentNetworkMode = -1;
  350.         int userNetworkMode = -1;
  351.         Phone[] phones = null; //all phone proxy instance
  352.         Phone phoneProxy = null; //current phone proxy instance
  355.         // For World phone OM version START
  356.         if ((SystemProperties.getInt(“ro.mtk_lte_support”, 0) == 1) &&
  357.             (SystemProperties.getInt(“ro.mtk_world_phone”, 0) == 1)) {
  358.             //get sim switch status
  359.             int switchStatus = Integer.valueOf(
  360.                     SystemProperties.get(PhoneConstants.CAPABILITY_SWITCH_PROP, “1”));
  362.             log(“needAutoSwitchRatMode,phoneId=” + phoneId+”, switchStatus=”+switchStatus+
  363.                 “,SubscriptionManager.isValidPhoneId(phoneId)=”+SubscriptionManager.isValidPhoneId(phoneId));
  365.             if ((phoneId == (switchStatus – 1)) &&
  366.                    SubscriptionManager.isValidPhoneId(phoneId)) {
  367.                 phones = PhoneFactory.getPhones();
  368.                 if (phones.length > phoneId) {
  369.                     phoneProxy = phones[phoneId];
  370.                 }
  372.                 if (phoneProxy == null) {
  373.                     log(“needSwitchRatMode()= -1 cause phone proxy is null”);
  374.                     return currentNetworkMode;
  375.                 }
  377.                 String simtype = null;
  378.                 simtype = ((PhoneProxy)phoneProxy).getIccCard().getIccCardType();
  379.                 if (simtype != null && simtype.equals(“SIM”)) {
  380.                     simType = 0;
  381.                 } else if (simtype != null && simtype.equals(“USIM”)) {
  382.                     simType = 1;
  383.                 }
  385.                 if (simType == 0) {//SIM
  386.                     //get rat mode if user has change it
  387.                     userNetworkMode = Settings.Global.getInt(mContext.getContentResolver(),
  388.                                             Settings.Global.USER_PREFERRED_NETWORK_MODE, -1);
  390.                     if (userNetworkMode >= Phone.NT_MODE_WCDMA_PREF) {
  391.                         currentNetworkMode = userNetworkMode;
  392.                         if(userNetworkMode >= Phone.NT_MODE_LTE_GSM_WCDMA) {
  393.                             currentNetworkMode = Phone.NT_MODE_WCDMA_PREF;
  394.                         }
  395.                         log(“DefaultServiceStateExt needSwitchRatMode for SIM: userNetworkMode=” + userNetworkMode);
  396.                     } else {
  397.                         //log(“needSwitchRatMode: set Rat to 2/3G auto”);
  398.                         currentNetworkMode = Phone.NT_MODE_WCDMA_PREF;
  399.                     }
  400.                 } else if (simType == 1) {//USIM
  401.                     //get rat mode if user has change it
  402.                     userNetworkMode = Settings.Global.getInt(mContext.getContentResolver(),
  403.                                             Settings.Global.USER_PREFERRED_NETWORK_MODE, -1);
  405.                     if (userNetworkMode >= Phone.NT_MODE_WCDMA_PREF) {
  406.                         log(“DefaultServiceStateExt needSwitchRatMode for USIM: userNetworkMode=” + userNetworkMode);
  407.                         currentNetworkMode = userNetworkMode;
  408.                     } else {
  409.                         //log(“needSwitchRatMode: set Rat to 4/3/2G”);
  410.                         currentNetworkMode = Phone.NT_MODE_LTE_GSM_WCDMA;
  411.                     }
  412.                 } else {
  413.                     log(“DefaultServiceStateExt unknown sim type, do nothing”);
  414.                 }
  415.             }
  416.         }
  417.         // For World phone OM version END
  419.         log(“DefaultServiceStateExt currentNetworkMode = “+currentNetworkMode+” ,simType= “+simType);
  420.         return currentNetworkMode;
  421.     }
  422.     */
  423.     //[ALPS01862093]-End
  425.     public boolean isSupportRatBalancing() {
  426.         return false;
  427.     }
  429.     /**
  430.      * Return if roaming for special SIM.
  431.      *
  432.      * @param strServingPlmn The operator numberic get from service state.
  433.      * @param strHomePlmn The mcc+mnc get from SIM IMSI.
  434.      * @return if roaming for the special SIM
  435.      */
  436.     public boolean isRoamingForSpecialSIM(String strServingPlmn, String strHomePlmn) {
  437.         return false;
  438.     }
  439. }

 

 

 

====================================================================================

  作者：欧阳鹏  欢迎转载，与人分享是进步的源泉！

  转载请保留原文地址：http://blog.csdn.net/ouyang_peng

====================================================================================

 

 

 

未經允許不得轉載：GoMCU » Android系统移植与调试之------->如何修改Android手机显示的4G信号强度的格子数

相關推薦