1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.telephony; 18 19 import android.os.Parcel; 20 import android.os.Parcelable; 21 import android.telephony.Rlog; 22 23 /** 24 * LTE signal strength related information. 25 */ 26 public final class CellSignalStrengthLte extends CellSignalStrength implements Parcelable { 27 28 private static final String LOG_TAG = "CellSignalStrengthLte"; 29 private static final boolean DBG = false; 30 31 private int mSignalStrength; 32 private int mRsrp; 33 private int mRsrq; 34 private int mRssnr; 35 private int mCqi; 36 private int mTimingAdvance; 37 38 /** 39 * Empty constructor 40 * 41 * @hide 42 */ CellSignalStrengthLte()43 public CellSignalStrengthLte() { 44 setDefaultValues(); 45 } 46 47 /** 48 * Constructor 49 * 50 * @hide 51 */ CellSignalStrengthLte(int signalStrength, int rsrp, int rsrq, int rssnr, int cqi, int timingAdvance)52 public CellSignalStrengthLte(int signalStrength, int rsrp, int rsrq, int rssnr, int cqi, 53 int timingAdvance) { 54 initialize(signalStrength, rsrp, rsrq, rssnr, cqi, timingAdvance); 55 } 56 57 /** 58 * Copy constructors 59 * 60 * @param s Source SignalStrength 61 * 62 * @hide 63 */ CellSignalStrengthLte(CellSignalStrengthLte s)64 public CellSignalStrengthLte(CellSignalStrengthLte s) { 65 copyFrom(s); 66 } 67 68 /** 69 * Initialize all the values 70 * 71 * @param lteSignalStrength 72 * @param rsrp 73 * @param rsrq 74 * @param rssnr 75 * @param cqi 76 * 77 * @hide 78 */ initialize(int lteSignalStrength, int rsrp, int rsrq, int rssnr, int cqi, int timingAdvance)79 public void initialize(int lteSignalStrength, int rsrp, int rsrq, int rssnr, int cqi, 80 int timingAdvance) { 81 mSignalStrength = lteSignalStrength; 82 mRsrp = rsrp; 83 mRsrq = rsrq; 84 mRssnr = rssnr; 85 mCqi = cqi; 86 mTimingAdvance = timingAdvance; 87 } 88 89 /** 90 * Initialize from the SignalStrength structure. 91 * 92 * @param ss 93 * 94 * @hide 95 */ initialize(SignalStrength ss, int timingAdvance)96 public void initialize(SignalStrength ss, int timingAdvance) { 97 mSignalStrength = ss.getLteSignalStrength(); 98 mRsrp = ss.getLteRsrp(); 99 mRsrq = ss.getLteRsrq(); 100 mRssnr = ss.getLteRssnr(); 101 mCqi = ss.getLteCqi(); 102 mTimingAdvance = timingAdvance; 103 } 104 105 /** 106 * @hide 107 */ copyFrom(CellSignalStrengthLte s)108 protected void copyFrom(CellSignalStrengthLte s) { 109 mSignalStrength = s.mSignalStrength; 110 mRsrp = s.mRsrp; 111 mRsrq = s.mRsrq; 112 mRssnr = s.mRssnr; 113 mCqi = s.mCqi; 114 mTimingAdvance = s.mTimingAdvance; 115 } 116 117 /** 118 * @hide 119 */ 120 @Override copy()121 public CellSignalStrengthLte copy() { 122 return new CellSignalStrengthLte(this); 123 } 124 125 /** @hide */ 126 @Override setDefaultValues()127 public void setDefaultValues() { 128 mSignalStrength = Integer.MAX_VALUE; 129 mRsrp = Integer.MAX_VALUE; 130 mRsrq = Integer.MAX_VALUE; 131 mRssnr = Integer.MAX_VALUE; 132 mCqi = Integer.MAX_VALUE; 133 mTimingAdvance = Integer.MAX_VALUE; 134 } 135 136 /** 137 * Get signal level as an int from 0..4 138 */ 139 @Override getLevel()140 public int getLevel() { 141 int levelRsrp = 0; 142 int levelRssnr = 0; 143 144 if (mRsrp == Integer.MAX_VALUE) levelRsrp = 0; 145 else if (mRsrp >= -95) levelRsrp = SIGNAL_STRENGTH_GREAT; 146 else if (mRsrp >= -105) levelRsrp = SIGNAL_STRENGTH_GOOD; 147 else if (mRsrp >= -115) levelRsrp = SIGNAL_STRENGTH_MODERATE; 148 else levelRsrp = SIGNAL_STRENGTH_POOR; 149 150 // See RIL_LTE_SignalStrength in ril.h 151 if (mRssnr == Integer.MAX_VALUE) levelRssnr = 0; 152 else if (mRssnr >= 45) levelRssnr = SIGNAL_STRENGTH_GREAT; 153 else if (mRssnr >= 10) levelRssnr = SIGNAL_STRENGTH_GOOD; 154 else if (mRssnr >= -30) levelRssnr = SIGNAL_STRENGTH_MODERATE; 155 else levelRssnr = SIGNAL_STRENGTH_POOR; 156 157 int level; 158 if (mRsrp == Integer.MAX_VALUE) 159 level = levelRssnr; 160 else if (mRssnr == Integer.MAX_VALUE) 161 level = levelRsrp; 162 else 163 level = (levelRssnr < levelRsrp) ? levelRssnr : levelRsrp; 164 165 if (DBG) log("Lte rsrp level: " + levelRsrp 166 + " snr level: " + levelRssnr + " level: " + level); 167 return level; 168 } 169 170 /** 171 * @hide 172 */ getRsrq()173 public int getRsrq() { 174 return mRsrq; 175 } 176 177 /** 178 * @hide 179 */ getRssnr()180 public int getRssnr() { 181 return mRssnr; 182 } 183 184 /** 185 * Get signal strength as dBm 186 */ 187 @Override getDbm()188 public int getDbm() { 189 return mRsrp; 190 } 191 192 /** 193 * Get the LTE signal level as an asu value between 0..97, 99 is unknown 194 * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69 195 */ 196 @Override getAsuLevel()197 public int getAsuLevel() { 198 int lteAsuLevel = 99; 199 int lteDbm = getDbm(); 200 if (lteDbm == Integer.MAX_VALUE) lteAsuLevel = 99; 201 else if (lteDbm <= -140) lteAsuLevel = 0; 202 else if (lteDbm >= -43) lteAsuLevel = 97; 203 else lteAsuLevel = lteDbm + 140; 204 if (DBG) log("Lte Asu level: "+lteAsuLevel); 205 return lteAsuLevel; 206 } 207 208 /** 209 * Get the timing advance value for LTE. 210 * See 3GPP xxxx 211 */ getTimingAdvance()212 public int getTimingAdvance() { 213 return mTimingAdvance; 214 } 215 216 @Override hashCode()217 public int hashCode() { 218 int primeNum = 31; 219 return (mSignalStrength * primeNum) + (mRsrp * primeNum) 220 + (mRsrq * primeNum) + (mRssnr * primeNum) + (mCqi * primeNum) 221 + (mTimingAdvance * primeNum); 222 } 223 224 @Override equals(Object o)225 public boolean equals (Object o) { 226 CellSignalStrengthLte s; 227 228 try { 229 s = (CellSignalStrengthLte) o; 230 } catch (ClassCastException ex) { 231 return false; 232 } 233 234 if (o == null) { 235 return false; 236 } 237 238 return mSignalStrength == s.mSignalStrength 239 && mRsrp == s.mRsrp 240 && mRsrq == s.mRsrq 241 && mRssnr == s.mRssnr 242 && mCqi == s.mCqi 243 && mTimingAdvance == s.mTimingAdvance; 244 } 245 246 /** 247 * @return string representation. 248 */ 249 @Override toString()250 public String toString() { 251 return "CellSignalStrengthLte:" 252 + " ss=" + mSignalStrength 253 + " rsrp=" + mRsrp 254 + " rsrq=" + mRsrq 255 + " rssnr=" + mRssnr 256 + " cqi=" + mCqi 257 + " ta=" + mTimingAdvance; 258 } 259 260 /** Implement the Parcelable interface */ 261 @Override writeToParcel(Parcel dest, int flags)262 public void writeToParcel(Parcel dest, int flags) { 263 if (DBG) log("writeToParcel(Parcel, int): " + toString()); 264 dest.writeInt(mSignalStrength); 265 // Need to multiply rsrp and rsrq by -1 266 // to ensure consistency when reading values written here 267 // unless the values are invalid 268 dest.writeInt(mRsrp * (mRsrp != Integer.MAX_VALUE ? -1 : 1)); 269 dest.writeInt(mRsrq * (mRsrq != Integer.MAX_VALUE ? -1 : 1)); 270 dest.writeInt(mRssnr); 271 dest.writeInt(mCqi); 272 dest.writeInt(mTimingAdvance); 273 } 274 275 /** 276 * Construct a SignalStrength object from the given parcel 277 * where the token is already been processed. 278 */ CellSignalStrengthLte(Parcel in)279 private CellSignalStrengthLte(Parcel in) { 280 mSignalStrength = in.readInt(); 281 // rsrp and rsrq are written into the parcel as positive values. 282 // Need to convert into negative values unless the values are invalid 283 mRsrp = in.readInt(); 284 if (mRsrp != Integer.MAX_VALUE) mRsrp *= -1; 285 mRsrq = in.readInt(); 286 if (mRsrq != Integer.MAX_VALUE) mRsrq *= -1; 287 mRssnr = in.readInt(); 288 mCqi = in.readInt(); 289 mTimingAdvance = in.readInt(); 290 if (DBG) log("CellSignalStrengthLte(Parcel): " + toString()); 291 } 292 293 /** Implement the Parcelable interface */ 294 @Override describeContents()295 public int describeContents() { 296 return 0; 297 } 298 299 /** Implement the Parcelable interface */ 300 @SuppressWarnings("hiding") 301 public static final Parcelable.Creator<CellSignalStrengthLte> CREATOR = 302 new Parcelable.Creator<CellSignalStrengthLte>() { 303 @Override 304 public CellSignalStrengthLte createFromParcel(Parcel in) { 305 return new CellSignalStrengthLte(in); 306 } 307 308 @Override 309 public CellSignalStrengthLte[] newArray(int size) { 310 return new CellSignalStrengthLte[size]; 311 } 312 }; 313 314 /** 315 * log 316 */ log(String s)317 private static void log(String s) { 318 Rlog.w(LOG_TAG, s); 319 } 320 } 321