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

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

           在修改显示的信号强度之前,先了解一下什么是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;
  16.         int rsrpThreshType = Resources.getSystem().getInteger(com.android.internal.R.integer.
  17.                 config_LTE_RSRP_threshold_type);
  18.         int[] threshRsrp;
  19.         if (rsrpThreshType == RSRP_THRESH_TYPE_STRICT) {
  20.             threshRsrp = RSRP_THRESH_STRICT;
  21.         } else {
  22.             threshRsrp = RSRP_THRESH_LENIENT;
  23.         }
  24.         //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  25.         if (!IS_BSP_PACKAGE) {
  26.             IServiceStateExt ssExt = getPlugInInstance();
  27.             if (ssExt != null) {
  28.                 rsrpIconLevel = ssExt.mapLteSignalLevel(mLteRsrp, mLteRssnr, mLteSignalStrength);
  29.                 //added by ouyang
  30.                 android.util.Log.e(“oyp”“ssExt != null, rsrpIconLevel:”+ rsrpIconLevel);
  31.                 return rsrpIconLevel;
  32.             } else {
  33.                 log(“[getLteLevel] null plug-in instance”);
  34.             }
  35.         }
  36.         //modifed by ouyang [2015-10-12] start
  37. //        if (mLteRsrp > -44) {
  38. //            rsrpIconLevel = -1;
  39. //        } else if (mLteRsrp >= -85) {
  40. //            rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  41. //        } else if (mLteRsrp >= -95) {
  42. //            rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  43. //        } else if (mLteRsrp >= -105) {
  44. //            rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  45. //        } else if (mLteRsrp >= -115) {
  46. //            rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  47. //        } else if (mLteRsrp >= -140) {
  48. //            rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  49. //        }
  50.         if (mLteRsrp > –44) {
  51.             rsrpIconLevel = –1;
  52.         } else if (mLteRsrp >= –97) {
  53.             rsrpIconLevel = SIGNAL_STRENGTH_GREAT;
  54.         } else if (mLteRsrp >= –105) {
  55.             rsrpIconLevel = SIGNAL_STRENGTH_GOOD;
  56.         } else if (mLteRsrp >= –110) {
  57.             rsrpIconLevel = SIGNAL_STRENGTH_MODERATE;
  58.         } else if (mLteRsrp >= –120) {
  59.             rsrpIconLevel = SIGNAL_STRENGTH_POOR;
  60.         } else if (mLteRsrp >= –140) {
  61.             rsrpIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  62.         }
  63.         //modifed by ouyang [2015-10-12] end
  64.         //added by ouyang
  65.         android.util.Log.e(“oyp”“getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”
  66.                         + rsrpIconLevel);
  67.         /*
  68.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  69.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  70.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  71.          * Icon Only
  72.          */
  73.         if (mLteRssnr > 300) {
  74.             snrIconLevel = –1;
  75.         } else if (mLteRssnr >= 130) {
  76.             snrIconLevel = SIGNAL_STRENGTH_GREAT;
  77.         } else if (mLteRssnr >= 45) {
  78.             snrIconLevel = SIGNAL_STRENGTH_GOOD;
  79.         } else if (mLteRssnr >= 10) {
  80.             snrIconLevel = SIGNAL_STRENGTH_MODERATE;
  81.         } else if (mLteRssnr >= –30) {
  82.             snrIconLevel = SIGNAL_STRENGTH_POOR;
  83.         } else if (mLteRssnr >= –200) {
  84.             snrIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  85.         }
  86.         //added by ouyang
  87.         android.util.Log.e(“oyp”“getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  88.         if (DBG) log(“getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  89.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  90.         /* Choose a measurement type to use for notification */
  91.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  92.             /*
  93.              * The number of bars displayed shall be the smaller of the bars
  94.              * associated with LTE RSRP and the bars associated with the LTE
  95.              * RS_SNR
  96.              */
  97.             //added by ouyang
  98.             android.util.Log.e(“oyp”“snrIconLevel != -1 && rsrpIconLevel != -1,”
  99.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  100.                          +(rsrpIconLevel < snrIconLevel));
  101.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  102.         }
  103.         if (snrIconLevel != –1) {
  104.             //added by ouyang
  105.             android.util.Log.e(“oyp”“snrIconLevel != -1”);
  106.             return snrIconLevel;
  107.         }
  108.         if (rsrpIconLevel != –1) {
  109.             //added by ouyang
  110.             android.util.Log.e(“oyp”“rsrpIconLevel != -1”);
  111.             return rsrpIconLevel;
  112.         }
  113.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  114.         if (mLteSignalStrength > 63) {
  115.             rssiIconLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  116.         } else if (mLteSignalStrength >= 12) {
  117.             rssiIconLevel = SIGNAL_STRENGTH_GREAT;
  118.         } else if (mLteSignalStrength >= 8) {
  119.             rssiIconLevel = SIGNAL_STRENGTH_GOOD;
  120.         } else if (mLteSignalStrength >= 5) {
  121.             rssiIconLevel = SIGNAL_STRENGTH_MODERATE;
  122.         } else if (mLteSignalStrength >= 0) {
  123.             rssiIconLevel = SIGNAL_STRENGTH_POOR;
  124.         }
  125.         //added by ouyang
  126.         android.util.Log.e(“oyp”“getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  127.                     + rssiIconLevel);
  128.         if (DBG) {
  129.             log(“getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  130.                     + rssiIconLevel);
  131.         }
  132.         return rssiIconLevel;
  133.         //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC
  134.     }

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

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

 

 

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

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.  */
  37. package com.mediatek.op.telephony;
  38. import android.content.Context;
  39. import android.content.res.Resources;
  40. import android.os.SystemProperties;
  41. import android.telephony.ServiceState;
  42. import android.telephony.SignalStrength;
  43. import android.util.Log;
  44. import com.mediatek.common.PluginImpl;
  45. import com.mediatek.common.telephony.IServiceStateExt;
  46. import android.provider.Settings;
  47. import android.telephony.SubscriptionManager;
  48. import com.android.internal.telephony.Phone;
  49. import com.android.internal.telephony.PhoneConstants;
  50. import com.android.internal.telephony.PhoneBase;
  51. import com.android.internal.telephony.PhoneFactory;
  52. import com.android.internal.telephony.PhoneProxy;
  53. import java.util.Map;
  54. @PluginImpl(interfaceName=“com.mediatek.common.telephony.IServiceStateExt”)
  55. public class DefaultServiceStateExt implements IServiceStateExt {
  56.     static final String TAG = “GSM”;
  57.     private Context mContext;
  58.     public DefaultServiceStateExt() {
  59.     }
  60.     public DefaultServiceStateExt(Context context) {
  61.         mContext = context;
  62.     }
  63.     public String onUpdateSpnDisplay(String plmn, ServiceState ss, int phoneId) {
  64.         /* ALPS00362903 */
  65.         if (SystemProperties.get(“ro.mtk_network_type_always_on”).equals(“1”)) {
  66.             // for LTE
  67.             if (ss.getRilVoiceRadioTechnology() == ServiceState.RIL_RADIO_TECHNOLOGY_LTE
  68.                 && plmn != Resources.getSystem().getText(com.android.internal.R.string.
  69.                         lockscreen_carrier_default).toString()) {
  70.                 plmn = plmn + ” 4G”;
  71.             } else if (ss.getRilVoiceRadioTechnology() > ServiceState.RIL_RADIO_TECHNOLOGY_EDGE
  72.                 /* ALPS00492303 */
  73.                 //if (radioTechnology > 2 && plmn != null){
  74.                     && plmn != Resources.getSystem().getText(com.android.internal.R.string.
  75.                             lockscreen_carrier_default).toString()) {
  76.                 plmn = plmn + ” 3G”;
  77.             }
  78.         }
  79.         return plmn;
  80.     }
  81.     public boolean isImeiLocked() {
  82.         return false;
  83.     }
  84.     public boolean isBroadcastEmmrrsPsResume(int value) {
  85.         return false;
  86.     }
  87.     public boolean needEMMRRS() {
  88.         return false;
  89.     }
  90.     public boolean needSpnRuleShowPlmnOnly() {
  91.         //[ALPS01679495]-start: don’t show SPN for CTA case
  92.         if (SystemProperties.get(“ro.mtk_cta_support”).equals(“1”)) {
  93.             return true;
  94.         }
  95.         //[ALPS01679495]-end
  96.         return false;
  97.     }
  98.     public boolean needBrodcastAcmt(int errorType, int errorCause) {
  99.         return false;
  100.     }
  101.     public boolean needRejectCauseNotification(int cause) {
  102.         return false;
  103.     }
  104.     public boolean needIgnoredState(int state, int newState, int cause) {
  105.         if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 2)) {
  106.             /* Don’t update for searching state, there shall be final registered state
  107.                update later */
  108.             Log.i(TAG, “set dontUpdateNetworkStateFlag for searching state”);
  109.             return true;
  110.         }
  111.         /* -1 means modem didn’t provide  information. */
  112.         if (cause != –1) {
  113.             // [ALPS01384143] need to check if previous state is IN_SERVICE for invalid sim
  114.             if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 3) && (cause != 0)) {
  115.             //if((newState == 3) && (cause != 0)){
  116.                 /* This is likely temporarily network failure, don’t update for better UX */
  117.                 Log.i(TAG, “set dontUpdateNetworkStateFlag for REG_DENIED with cause”);
  118.                 return true;
  119.             //[ALPS01976914] – start
  120.             } else if ((state == ServiceState.STATE_IN_SERVICE) && (newState == 0) && (cause != 0)) {
  121.                 Log.i(TAG, “set dontUpdateNetworkStateFlag for NOT_REG_AND_NOT_SEARCH with cause”);
  122.                 return true;
  123.             }
  124.             //[ALPS01976914] – end
  125.         }
  126.         Log.i(TAG, “clear dontUpdateNetworkStateFlag”);
  127.         return false;
  128.     }
  129.     public boolean ignoreDomesticRoaming() {
  130.         return false;
  131.     }
  132.     public int mapGsmSignalLevel(int asu, int gsmRscpQdbm) {
  133.         int level;
  134.         // [ALPS01055164] — START , for 3G network
  135.         if (gsmRscpQdbm < 0) {
  136.             // 3G network
  137.             if (asu <= 5 || asu == 99) {
  138.                 level = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  139.             } else if (asu >= 15) {
  140.                 level = SignalStrength.SIGNAL_STRENGTH_GREAT;
  141.             } else if (asu >= 12) {
  142.                 level = SignalStrength.SIGNAL_STRENGTH_GOOD;
  143.             } else if (asu >= 9) {
  144.                 level = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  145.             } else {
  146.                 level = SignalStrength.SIGNAL_STRENGTH_POOR;
  147.             }
  148.         // [ALPS01055164] — END
  149.         } else {
  150.             // 2G network
  151.             if (asu <= 2 || asu == 99) {
  152.                 level = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  153.             } else if (asu >= 12) {
  154.                 level = SignalStrength.SIGNAL_STRENGTH_GREAT;
  155.             } else if (asu >= 8) {
  156.                 level = SignalStrength.SIGNAL_STRENGTH_GOOD;
  157.             } else if (asu >= 5) {
  158.                 level = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  159.             } else {
  160.                 level = SignalStrength.SIGNAL_STRENGTH_POOR;
  161.             }
  162.         }
  163.         return level;
  164.     }
  165.     //[ALPS01440836][ALPS01594704]-START: change level mapping rule of signal for CMCC
  166.     public int mapLteSignalLevel(int mLteRsrp, int mLteRssnr, int mLteSignalStrength) {
  167.           //added by ouyang
  168.                 android.util.Log.e(“mapLteSignalLevel”“mapLteSignalLevel starting …….”);
  169.         /*
  170.          * TS 36.214 Physical Layer Section 5.1.3 TS 36.331 RRC RSSI = received
  171.          * signal + noise RSRP = reference signal dBm RSRQ = quality of signal
  172.          * dB= Number of Resource blocksxRSRP/RSSI SNR = gain=signal/noise ratio
  173.          * = -10log P1/P2 dB
  174.          */
  175.         int rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  176.         int rsrpIconLevel = –1;
  177.         int snrIconLevel = –1;
  178.                 //modifed by ouyang [2015-10-14] start
  179. //        if (mLteRsrp > -44) {
  180. //            rsrpIconLevel = -1;
  181. //        } else if (mLteRsrp >= -85) {
  182. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  183. //        } else if (mLteRsrp >= -95) {
  184. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  185. //        } else if (mLteRsrp >= -105) {
  186. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  187. //        } else if (mLteRsrp >= -115) {
  188. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  189. //        } else if (mLteRsrp >= -140) {
  190. //            rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  191. //        }
  192.         if (mLteRsrp > –44) {
  193.             rsrpIconLevel = –1;
  194.         } else if (mLteRsrp >= –97) {
  195.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  196.         } else if (mLteRsrp >= –105) {
  197.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  198.         } else if (mLteRsrp >= –110) {
  199.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  200.         } else if (mLteRsrp >= –120) {
  201.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  202.         } else if (mLteRsrp >= –140) {
  203.             rsrpIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  204.         }
  205.                 //added by ouyang
  206.                 android.util.Log.e(“mapLteSignalLevel”“getLTELevel – rsrp:” + mLteRsrp + ” rsrpIconLevel:”+ rsrpIconLevel);
  207.             //modifed by ouyang [2015-10-14] end
  208.         /*
  209.          * Values are -200 dB to +300 (SNR*10dB) RS_SNR >= 13.0 dB =>4 bars 4.5
  210.          * dB <= RS_SNR < 13.0 dB => 3 bars 1.0 dB <= RS_SNR < 4.5 dB => 2 bars
  211.          * -3.0 dB <= RS_SNR < 1.0 dB 1 bar RS_SNR < -3.0 dB/No Service Antenna
  212.          * Icon Only
  213.          */
  214.         if (mLteRssnr > 300) {
  215.             snrIconLevel = –1;
  216.         } else if (mLteRssnr >= 130) {
  217.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  218.         } else if (mLteRssnr >= 45) {
  219.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  220.         } else if (mLteRssnr >= 10) {
  221.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  222.         } else if (mLteRssnr >= –30) {
  223.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  224.         } else if (mLteRssnr >= –200) {
  225.             snrIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  226.         }
  227.         //added by ouyang
  228.             android.util.Log.e(“mapLteSignalLevel”“getLTELevel – snr:” + mLteRssnr + ” snrIconLevel:” + snrIconLevel);
  229.         Log.i(TAG, “getLTELevel – rsrp:” + mLteRsrp + ” snr:” + mLteRssnr + ” rsrpIconLevel:”
  230.                 + rsrpIconLevel + ” snrIconLevel:” + snrIconLevel);
  231.         /* Choose a measurement type to use for notification */
  232.         if (snrIconLevel != –1 && rsrpIconLevel != –1) {
  233.             /*
  234.              * The number of bars displayed shall be the smaller of the bars
  235.              * associated with LTE RSRP and the bars associated with the LTE
  236.              * RS_SNR
  237.              */
  238.              //added by ouyang
  239.                          android.util.Log.e(“mapLteSignalLevel”“snrIconLevel != -1 && rsrpIconLevel != -1,”
  240.                          +“return rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel”
  241.                          +(rsrpIconLevel < snrIconLevel));
  242.             return (rsrpIconLevel < snrIconLevel ? rsrpIconLevel : snrIconLevel);
  243.         }
  244.         if (snrIconLevel != –1) {
  245.                 //added by ouyang
  246.                         android.util.Log.e(“mapLteSignalLevel”“snrIconLevel != -1”);
  247.             return snrIconLevel;
  248.         }
  249.         if (rsrpIconLevel != –1) {
  250.                 //added by ouyang
  251.                         android.util.Log.e(“mapLteSignalLevel”“rsrpIconLevel != -1”);
  252.             return rsrpIconLevel;
  253.         }
  254.         /* Valid values are (0-63, 99) as defined in TS 36.331 */
  255.         if (mLteSignalStrength > 63) {
  256.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN;
  257.         } else if (mLteSignalStrength >= 12) {
  258.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GREAT;
  259.         } else if (mLteSignalStrength >= 8) {
  260.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_GOOD;
  261.         } else if (mLteSignalStrength >= 5) {
  262.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_MODERATE;
  263.         } else if (mLteSignalStrength >= 0) {
  264.             rssiIconLevel = SignalStrength.SIGNAL_STRENGTH_POOR;
  265.         }
  266.         //added by ouyang
  267.                 android.util.Log.e(“mapLteSignalLevel”“getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  268.                     + rssiIconLevel);
  269.         Log.i(TAG, “getLTELevel – rssi:” + mLteSignalStrength + ” rssiIconLevel:”
  270.                 + rssiIconLevel);
  271.         return rssiIconLevel;
  272.     }
  273.     //[ALPS01440836][ALPS01594704]-END: change level mapping rule of signal for CMCC
  274.     public int mapGsmSignalDbm(int gsmRscpQdbm, int asu) {
  275.         int dBm;
  276.         Log.d(TAG, “mapGsmSignalDbm() gsmRscpQdbm=” + gsmRscpQdbm + ” asu=” + asu);
  277.         if (gsmRscpQdbm < 0) {
  278.             dBm = gsmRscpQdbm / 4//Return raw value for 3G Network
  279.         } else {
  280.             dBm = –113 + (2 * asu);
  281.         }
  282.         return dBm;
  283.     }
  284.     public void log(String text) {
  285.         Log.d(TAG, text);
  286.     }
  287.     public Map loadSpnOverrides() {
  288.         return null;
  289.     }
  290.     public boolean allowSpnDisplayed() {
  291.         return true;
  292.     }
  293.     public boolean supportEccForEachSIM() {
  294.         return false;
  295.     }
  296.     public void updateOplmn(Context context, Object ci) {
  297.     }
  298.     //[ALPS01558804] MTK-START: send notification for using some spcial icc card
  299.     public boolean needIccCardTypeNotification(String iccCardType) {
  300.         return false;
  301.     }
  302.     //[ALPS01862093]-Start: not supprot auto switch rat for SIM card type
  303.     //du to UI spec. define chagend
  304.     public int needAutoSwitchRatMode(int phoneId, String nwPlmn) {
  305.         return –1;
  306.     }
  307.     //re-mark
  308.     /*
  309.     //[ALPS01577029] To support auto switch rat mode
  310.     public int needAutoSwitchRatMode(int phoneId,String nwPlmn) {
  311.         int simType = -1; // 0: SIM , 1: USIM
  312.         int currentNetworkMode = -1;
  313.         int userNetworkMode = -1;
  314.         Phone[] phones = null; //all phone proxy instance
  315.         Phone phoneProxy = null; //current phone proxy instance
  316.         // For World phone OM version START
  317.         if ((SystemProperties.getInt(“ro.mtk_lte_support”, 0) == 1) &&
  318.             (SystemProperties.getInt(“ro.mtk_world_phone”, 0) == 1)) {
  319.             //get sim switch status
  320.             int switchStatus = Integer.valueOf(
  321.                     SystemProperties.get(PhoneConstants.CAPABILITY_SWITCH_PROP, “1”));
  322.             log(“needAutoSwitchRatMode,phoneId=” + phoneId+”, switchStatus=”+switchStatus+
  323.                 “,SubscriptionManager.isValidPhoneId(phoneId)=”+SubscriptionManager.isValidPhoneId(phoneId));
  324.             if ((phoneId == (switchStatus – 1)) &&
  325.                    SubscriptionManager.isValidPhoneId(phoneId)) {
  326.                 phones = PhoneFactory.getPhones();
  327.                 if (phones.length > phoneId) {
  328.                     phoneProxy = phones[phoneId];
  329.                 }
  330.                 if (phoneProxy == null) {
  331.                     log(“needSwitchRatMode()= -1 cause phone proxy is null”);
  332.                     return currentNetworkMode;
  333.                 }
  334.                 String simtype = null;
  335.                 simtype = ((PhoneProxy)phoneProxy).getIccCard().getIccCardType();
  336.                 if (simtype != null && simtype.equals(“SIM”)) {
  337.                     simType = 0;
  338.                 } else if (simtype != null && simtype.equals(“USIM”)) {
  339.                     simType = 1;
  340.                 }
  341.                 if (simType == 0) {//SIM
  342.                     //get rat mode if user has change it
  343.                     userNetworkMode = Settings.Global.getInt(mContext.getContentResolver(),
  344.                                             Settings.Global.USER_PREFERRED_NETWORK_MODE, -1);
  345.                     if (userNetworkMode >= Phone.NT_MODE_WCDMA_PREF) {
  346.                         currentNetworkMode = userNetworkMode;
  347.                         if(userNetworkMode >= Phone.NT_MODE_LTE_GSM_WCDMA) {
  348.                             currentNetworkMode = Phone.NT_MODE_WCDMA_PREF;
  349.                         }
  350.                         log(“DefaultServiceStateExt needSwitchRatMode for SIM: userNetworkMode=” + userNetworkMode);
  351.                     } else {
  352.                         //log(“needSwitchRatMode: set Rat to 2/3G auto”);
  353.                         currentNetworkMode = Phone.NT_MODE_WCDMA_PREF;
  354.                     }
  355.                 } else if (simType == 1) {//USIM
  356.                     //get rat mode if user has change it
  357.                     userNetworkMode = Settings.Global.getInt(mContext.getContentResolver(),
  358.                                             Settings.Global.USER_PREFERRED_NETWORK_MODE, -1);
  359.                     if (userNetworkMode >= Phone.NT_MODE_WCDMA_PREF) {
  360.                         log(“DefaultServiceStateExt needSwitchRatMode for USIM: userNetworkMode=” + userNetworkMode);
  361.                         currentNetworkMode = userNetworkMode;
  362.                     } else {
  363.                         //log(“needSwitchRatMode: set Rat to 4/3/2G”);
  364.                         currentNetworkMode = Phone.NT_MODE_LTE_GSM_WCDMA;
  365.                     }
  366.                 } else {
  367.                     log(“DefaultServiceStateExt unknown sim type, do nothing”);
  368.                 }
  369.             }
  370.         }
  371.         // For World phone OM version END
  372.         log(“DefaultServiceStateExt currentNetworkMode = “+currentNetworkMode+” ,simType= “+simType);
  373.         return currentNetworkMode;
  374.     }
  375.     */
  376.     //[ALPS01862093]-End
  377.     public boolean isSupportRatBalancing() {
  378.         return false;
  379.     }
  380.     /**
  381.      * Return if roaming for special SIM.
  382.      *
  383.      * @param strServingPlmn The operator numberic get from service state.
  384.      * @param strHomePlmn The mcc+mnc get from SIM IMSI.
  385.      * @return if roaming for the special SIM
  386.      */
  387.     public boolean isRoamingForSpecialSIM(String strServingPlmn, String strHomePlmn) {
  388.         return false;
  389.     }
  390. }

 

 

 

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

  作者:欧阳鹏  欢迎转载,与人分享是进步的源泉!

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

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

 

 

 

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

評論 搶沙發

  • 昵稱 (必填)
  • 郵箱 (必填)
  • 網址