1 /* 2 * Copyright (C) 2009 Qualcomm Innovation Center, Inc. All Rights Reserved. 3 * Copyright (C) 2009 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package android.telephony; 19 20 import android.os.Bundle; 21 import android.os.Parcel; 22 import android.os.Parcelable; 23 import android.util.Log; 24 25 /** 26 * Contains phone signal strength related information. 27 */ 28 public class SignalStrength implements Parcelable { 29 30 private static final String LOG_TAG = "SignalStrength"; 31 private static final boolean DBG = false; 32 33 /** @hide */ 34 public static final int SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0; 35 /** @hide */ 36 public static final int SIGNAL_STRENGTH_POOR = 1; 37 /** @hide */ 38 public static final int SIGNAL_STRENGTH_MODERATE = 2; 39 /** @hide */ 40 public static final int SIGNAL_STRENGTH_GOOD = 3; 41 /** @hide */ 42 public static final int SIGNAL_STRENGTH_GREAT = 4; 43 /** @hide */ 44 public static final int NUM_SIGNAL_STRENGTH_BINS = 5; 45 /** @hide */ 46 public static final String[] SIGNAL_STRENGTH_NAMES = { 47 "none", "poor", "moderate", "good", "great" 48 }; 49 50 private int mGsmSignalStrength; // Valid values are (0-31, 99) as defined in TS 27.007 8.5 51 private int mGsmBitErrorRate; // bit error rate (0-7, 99) as defined in TS 27.007 8.5 52 private int mCdmaDbm; // This value is the RSSI value 53 private int mCdmaEcio; // This value is the Ec/Io 54 private int mEvdoDbm; // This value is the EVDO RSSI value 55 private int mEvdoEcio; // This value is the EVDO Ec/Io 56 private int mEvdoSnr; // Valid values are 0-8. 8 is the highest signal to noise ratio 57 private int mLteSignalStrength; 58 private int mLteRsrp; 59 private int mLteRsrq; 60 private int mLteRssnr; 61 private int mLteCqi; 62 63 private boolean isGsm; // This value is set by the ServiceStateTracker onSignalStrengthResult 64 65 /** 66 * Create a new SignalStrength from a intent notifier Bundle 67 * 68 * This method is used by PhoneStateIntentReceiver and maybe by 69 * external applications. 70 * 71 * @param m Bundle from intent notifier 72 * @return newly created SignalStrength 73 * 74 * @hide 75 */ 76 public static SignalStrength newFromBundle(Bundle m) { 77 SignalStrength ret; 78 ret = new SignalStrength(); 79 ret.setFromNotifierBundle(m); 80 return ret; 81 } 82 83 /** 84 * Empty constructor 85 * 86 * @hide 87 */ 88 public SignalStrength() { 89 mGsmSignalStrength = 99; 90 mGsmBitErrorRate = -1; 91 mCdmaDbm = -1; 92 mCdmaEcio = -1; 93 mEvdoDbm = -1; 94 mEvdoEcio = -1; 95 mEvdoSnr = -1; 96 mLteSignalStrength = -1; 97 mLteRsrp = -1; 98 mLteRsrq = -1; 99 mLteRssnr = -1; 100 mLteCqi = -1; 101 isGsm = true; 102 } 103 104 /** 105 * Constructor 106 * 107 * @hide 108 */ 109 public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate, 110 int cdmaDbm, int cdmaEcio, 111 int evdoDbm, int evdoEcio, int evdoSnr, 112 int lteSignalStrength, int lteRsrp, int lteRsrq, int lteRssnr, int lteCqi, 113 boolean gsm) { 114 mGsmSignalStrength = gsmSignalStrength; 115 mGsmBitErrorRate = gsmBitErrorRate; 116 mCdmaDbm = cdmaDbm; 117 mCdmaEcio = cdmaEcio; 118 mEvdoDbm = evdoDbm; 119 mEvdoEcio = evdoEcio; 120 mEvdoSnr = evdoSnr; 121 mLteSignalStrength = lteSignalStrength; 122 mLteRsrp = lteRsrp; 123 mLteRsrq = lteRsrq; 124 mLteRssnr = lteRssnr; 125 mLteCqi = lteCqi; 126 isGsm = gsm; 127 } 128 129 /** 130 * Constructor 131 * 132 * @hide 133 */ 134 public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate, 135 int cdmaDbm, int cdmaEcio, 136 int evdoDbm, int evdoEcio, int evdoSnr, 137 boolean gsm) { 138 this(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio, 139 evdoDbm, evdoEcio, evdoSnr, -1, -1, -1, -1, -1, gsm); 140 } 141 142 /** 143 * Copy constructors 144 * 145 * @param s Source SignalStrength 146 * 147 * @hide 148 */ 149 public SignalStrength(SignalStrength s) { 150 copyFrom(s); 151 } 152 153 /** 154 * @hide 155 */ 156 protected void copyFrom(SignalStrength s) { 157 mGsmSignalStrength = s.mGsmSignalStrength; 158 mGsmBitErrorRate = s.mGsmBitErrorRate; 159 mCdmaDbm = s.mCdmaDbm; 160 mCdmaEcio = s.mCdmaEcio; 161 mEvdoDbm = s.mEvdoDbm; 162 mEvdoEcio = s.mEvdoEcio; 163 mEvdoSnr = s.mEvdoSnr; 164 mLteSignalStrength = s.mLteSignalStrength; 165 mLteRsrp = s.mLteRsrp; 166 mLteRsrq = s.mLteRsrq; 167 mLteRssnr = s.mLteRssnr; 168 mLteCqi = s.mLteCqi; 169 isGsm = s.isGsm; 170 } 171 172 /** 173 * Construct a SignalStrength object from the given parcel. 174 * 175 * @hide 176 */ 177 public SignalStrength(Parcel in) { 178 mGsmSignalStrength = in.readInt(); 179 mGsmBitErrorRate = in.readInt(); 180 mCdmaDbm = in.readInt(); 181 mCdmaEcio = in.readInt(); 182 mEvdoDbm = in.readInt(); 183 mEvdoEcio = in.readInt(); 184 mEvdoSnr = in.readInt(); 185 mLteSignalStrength = in.readInt(); 186 mLteRsrp = in.readInt(); 187 mLteRsrq = in.readInt(); 188 mLteRssnr = in.readInt(); 189 mLteCqi = in.readInt(); 190 isGsm = (in.readInt() != 0); 191 } 192 193 /** 194 * {@link Parcelable#writeToParcel} 195 */ 196 public void writeToParcel(Parcel out, int flags) { 197 out.writeInt(mGsmSignalStrength); 198 out.writeInt(mGsmBitErrorRate); 199 out.writeInt(mCdmaDbm); 200 out.writeInt(mCdmaEcio); 201 out.writeInt(mEvdoDbm); 202 out.writeInt(mEvdoEcio); 203 out.writeInt(mEvdoSnr); 204 out.writeInt(mLteSignalStrength); 205 out.writeInt(mLteRsrp); 206 out.writeInt(mLteRsrq); 207 out.writeInt(mLteRssnr); 208 out.writeInt(mLteCqi); 209 out.writeInt(isGsm ? 1 : 0); 210 } 211 212 /** 213 * {@link Parcelable#describeContents} 214 */ 215 public int describeContents() { 216 return 0; 217 } 218 219 /** 220 * {@link Parcelable.Creator} 221 * 222 * @hide 223 */ 224 public static final Parcelable.Creator<SignalStrength> CREATOR = new Parcelable.Creator() { 225 public SignalStrength createFromParcel(Parcel in) { 226 return new SignalStrength(in); 227 } 228 229 public SignalStrength[] newArray(int size) { 230 return new SignalStrength[size]; 231 } 232 }; 233 234 /** 235 * Get the GSM Signal Strength, valid values are (0-31, 99) as defined in TS 27.007 8.5 236 */ 237 public int getGsmSignalStrength() { 238 return this.mGsmSignalStrength; 239 } 240 241 /** 242 * Get the GSM bit error rate (0-7, 99) as defined in TS 27.007 8.5 243 */ 244 public int getGsmBitErrorRate() { 245 return this.mGsmBitErrorRate; 246 } 247 248 /** 249 * Get the CDMA RSSI value in dBm 250 */ 251 public int getCdmaDbm() { 252 return this.mCdmaDbm; 253 } 254 255 /** 256 * Get the CDMA Ec/Io value in dB*10 257 */ 258 public int getCdmaEcio() { 259 return this.mCdmaEcio; 260 } 261 262 /** 263 * Get the EVDO RSSI value in dBm 264 */ 265 public int getEvdoDbm() { 266 return this.mEvdoDbm; 267 } 268 269 /** 270 * Get the EVDO Ec/Io value in dB*10 271 */ 272 public int getEvdoEcio() { 273 return this.mEvdoEcio; 274 } 275 276 /** 277 * Get the signal to noise ratio. Valid values are 0-8. 8 is the highest. 278 */ 279 public int getEvdoSnr() { 280 return this.mEvdoSnr; 281 } 282 283 /** 284 * Get signal level as an int from 0..4 285 * 286 * @hide 287 */ 288 public int getLevel() { 289 int level; 290 291 if (isGsm) { 292 if ((mLteSignalStrength == -1) 293 && (mLteRsrp == -1) 294 && (mLteRsrq == -1) 295 && (mLteRssnr == -1) 296 && (mLteCqi == -1)) { 297 level = getGsmLevel(); 298 } else { 299 level = getLteLevel(); 300 } 301 } else { 302 int cdmaLevel = getCdmaLevel(); 303 int evdoLevel = getEvdoLevel(); 304 if (evdoLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) { 305 /* We don't know evdo, use cdma */ 306 level = getCdmaLevel(); 307 } else if (cdmaLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) { 308 /* We don't know cdma, use evdo */ 309 level = getEvdoLevel(); 310 } else { 311 /* We know both, use the lowest level */ 312 level = cdmaLevel < evdoLevel ? cdmaLevel : evdoLevel; 313 } 314 } 315 if (DBG) log("getLevel=" + level); 316 return level; 317 } 318 319 /** 320 * Get the signal level as an asu value between 0..31, 99 is unknown 321 * 322 * @hide 323 */ 324 public int getAsuLevel() { 325 int asuLevel; 326 if (isGsm) { 327 if ((mLteSignalStrength == -1) 328 && (mLteRsrp == -1) 329 && (mLteRsrq == -1) 330 && (mLteRssnr == -1) 331 && (mLteCqi == -1)) { 332 asuLevel = getGsmAsuLevel(); 333 } else { 334 asuLevel = getLteAsuLevel(); 335 } 336 } else { 337 int cdmaAsuLevel = getCdmaAsuLevel(); 338 int evdoAsuLevel = getEvdoAsuLevel(); 339 if (evdoAsuLevel == 0) { 340 /* We don't know evdo use, cdma */ 341 asuLevel = cdmaAsuLevel; 342 } else if (cdmaAsuLevel == 0) { 343 /* We don't know cdma use, evdo */ 344 asuLevel = evdoAsuLevel; 345 } else { 346 /* We know both, use the lowest level */ 347 asuLevel = cdmaAsuLevel < evdoAsuLevel ? cdmaAsuLevel : evdoAsuLevel; 348 } 349 } 350 if (DBG) log("getAsuLevel=" + asuLevel); 351 return asuLevel; 352 } 353 354 /** 355 * Get the signal strength as dBm 356 * 357 * @hide 358 */ 359 public int getDbm() { 360 int dBm; 361 362 if(isGsm()) { 363 if ((mLteSignalStrength == -1) 364 && (mLteRsrp == -1) 365 && (mLteRsrq == -1) 366 && (mLteRssnr == -1) 367 && (mLteCqi == -1)) { 368 dBm = getGsmDbm(); 369 } else { 370 dBm = getLteDbm(); 371 } 372 } else { 373 dBm = getCdmaDbm(); 374 } 375 if (DBG) log("getDbm=" + dBm); 376 return dBm; 377 } 378 379 /** 380 * Get Gsm signal strength as dBm 381 * 382 * @hide 383 */ 384 public int getGsmDbm() { 385 int dBm; 386 387 int gsmSignalStrength = getGsmSignalStrength(); 388 int asu = (gsmSignalStrength == 99 ? -1 : gsmSignalStrength); 389 if (asu != -1) { 390 dBm = -113 + (2 * asu); 391 } else { 392 dBm = -1; 393 } 394 if (DBG) log("getGsmDbm=" + dBm); 395 return dBm; 396 } 397 398 /** 399 * Get gsm as level 0..4 400 * 401 * @hide 402 */ 403 public int getGsmLevel() { 404 int level; 405 406 // ASU ranges from 0 to 31 - TS 27.007 Sec 8.5 407 // asu = 0 (-113dB or less) is very weak 408 // signal, its better to show 0 bars to the user in such cases. 409 // asu = 99 is a special case, where the signal strength is unknown. 410 int asu = getGsmSignalStrength(); 411 if (asu <= 2 || asu == 99) level = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; 412 else if (asu >= 12) level = SIGNAL_STRENGTH_GREAT; 413 else if (asu >= 8) level = SIGNAL_STRENGTH_GOOD; 414 else if (asu >= 5) level = SIGNAL_STRENGTH_MODERATE; 415 else level = SIGNAL_STRENGTH_POOR; 416 if (DBG) log("getGsmLevel=" + level); 417 return level; 418 } 419 420 /** 421 * Get the gsm signal level as an asu value between 0..31, 99 is unknown 422 * 423 * @hide 424 */ 425 public int getGsmAsuLevel() { 426 // ASU ranges from 0 to 31 - TS 27.007 Sec 8.5 427 // asu = 0 (-113dB or less) is very weak 428 // signal, its better to show 0 bars to the user in such cases. 429 // asu = 99 is a special case, where the signal strength is unknown. 430 int level = getGsmSignalStrength(); 431 if (DBG) log("getGsmAsuLevel=" + level); 432 return level; 433 } 434 435 /** 436 * Get cdma as level 0..4 437 * 438 * @hide 439 */ 440 public int getCdmaLevel() { 441 final int cdmaDbm = getCdmaDbm(); 442 final int cdmaEcio = getCdmaEcio(); 443 int levelDbm; 444 int levelEcio; 445 446 if (cdmaDbm >= -75) levelDbm = SIGNAL_STRENGTH_GREAT; 447 else if (cdmaDbm >= -85) levelDbm = SIGNAL_STRENGTH_GOOD; 448 else if (cdmaDbm >= -95) levelDbm = SIGNAL_STRENGTH_MODERATE; 449 else if (cdmaDbm >= -100) levelDbm = SIGNAL_STRENGTH_POOR; 450 else levelDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; 451 452 // Ec/Io are in dB*10 453 if (cdmaEcio >= -90) levelEcio = SIGNAL_STRENGTH_GREAT; 454 else if (cdmaEcio >= -110) levelEcio = SIGNAL_STRENGTH_GOOD; 455 else if (cdmaEcio >= -130) levelEcio = SIGNAL_STRENGTH_MODERATE; 456 else if (cdmaEcio >= -150) levelEcio = SIGNAL_STRENGTH_POOR; 457 else levelEcio = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; 458 459 int level = (levelDbm < levelEcio) ? levelDbm : levelEcio; 460 if (DBG) log("getCdmaLevel=" + level); 461 return level; 462 } 463 464 /** 465 * Get the cdma signal level as an asu value between 0..31, 99 is unknown 466 * 467 * @hide 468 */ 469 public int getCdmaAsuLevel() { 470 final int cdmaDbm = getCdmaDbm(); 471 final int cdmaEcio = getCdmaEcio(); 472 int cdmaAsuLevel; 473 int ecioAsuLevel; 474 475 if (cdmaDbm >= -75) cdmaAsuLevel = 16; 476 else if (cdmaDbm >= -82) cdmaAsuLevel = 8; 477 else if (cdmaDbm >= -90) cdmaAsuLevel = 4; 478 else if (cdmaDbm >= -95) cdmaAsuLevel = 2; 479 else if (cdmaDbm >= -100) cdmaAsuLevel = 1; 480 else cdmaAsuLevel = 99; 481 482 // Ec/Io are in dB*10 483 if (cdmaEcio >= -90) ecioAsuLevel = 16; 484 else if (cdmaEcio >= -100) ecioAsuLevel = 8; 485 else if (cdmaEcio >= -115) ecioAsuLevel = 4; 486 else if (cdmaEcio >= -130) ecioAsuLevel = 2; 487 else if (cdmaEcio >= -150) ecioAsuLevel = 1; 488 else ecioAsuLevel = 99; 489 490 int level = (cdmaAsuLevel < ecioAsuLevel) ? cdmaAsuLevel : ecioAsuLevel; 491 if (DBG) log("getCdmaAsuLevel=" + level); 492 return level; 493 } 494 495 /** 496 * Get Evdo as level 0..4 497 * 498 * @hide 499 */ 500 public int getEvdoLevel() { 501 int evdoDbm = getEvdoDbm(); 502 int evdoSnr = getEvdoSnr(); 503 int levelEvdoDbm; 504 int levelEvdoSnr; 505 506 if (evdoDbm >= -65) levelEvdoDbm = SIGNAL_STRENGTH_GREAT; 507 else if (evdoDbm >= -75) levelEvdoDbm = SIGNAL_STRENGTH_GOOD; 508 else if (evdoDbm >= -90) levelEvdoDbm = SIGNAL_STRENGTH_MODERATE; 509 else if (evdoDbm >= -105) levelEvdoDbm = SIGNAL_STRENGTH_POOR; 510 else levelEvdoDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; 511 512 if (evdoSnr >= 7) levelEvdoSnr = SIGNAL_STRENGTH_GREAT; 513 else if (evdoSnr >= 5) levelEvdoSnr = SIGNAL_STRENGTH_GOOD; 514 else if (evdoSnr >= 3) levelEvdoSnr = SIGNAL_STRENGTH_MODERATE; 515 else if (evdoSnr >= 1) levelEvdoSnr = SIGNAL_STRENGTH_POOR; 516 else levelEvdoSnr = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; 517 518 int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr; 519 if (DBG) log("getEvdoLevel=" + level); 520 return level; 521 } 522 523 /** 524 * Get the evdo signal level as an asu value between 0..31, 99 is unknown 525 * 526 * @hide 527 */ 528 public int getEvdoAsuLevel() { 529 int evdoDbm = getEvdoDbm(); 530 int evdoSnr = getEvdoSnr(); 531 int levelEvdoDbm; 532 int levelEvdoSnr; 533 534 if (evdoDbm >= -65) levelEvdoDbm = 16; 535 else if (evdoDbm >= -75) levelEvdoDbm = 8; 536 else if (evdoDbm >= -85) levelEvdoDbm = 4; 537 else if (evdoDbm >= -95) levelEvdoDbm = 2; 538 else if (evdoDbm >= -105) levelEvdoDbm = 1; 539 else levelEvdoDbm = 99; 540 541 if (evdoSnr >= 7) levelEvdoSnr = 16; 542 else if (evdoSnr >= 6) levelEvdoSnr = 8; 543 else if (evdoSnr >= 5) levelEvdoSnr = 4; 544 else if (evdoSnr >= 3) levelEvdoSnr = 2; 545 else if (evdoSnr >= 1) levelEvdoSnr = 1; 546 else levelEvdoSnr = 99; 547 548 int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr; 549 if (DBG) log("getEvdoAsuLevel=" + level); 550 return level; 551 } 552 553 /** 554 * Get LTE as dBm 555 * 556 * @hide 557 */ 558 public int getLteDbm() { 559 return mLteRsrp; 560 } 561 562 /** 563 * Get LTE as level 0..4 564 * 565 * @hide 566 */ 567 public int getLteLevel() { 568 int levelLteRsrp = 0; 569 570 if (mLteRsrp == -1) levelLteRsrp = 0; 571 else if (mLteRsrp >= -85) levelLteRsrp = SIGNAL_STRENGTH_GREAT; 572 else if (mLteRsrp >= -95) levelLteRsrp = SIGNAL_STRENGTH_GOOD; 573 else if (mLteRsrp >= -105) levelLteRsrp = SIGNAL_STRENGTH_MODERATE; 574 else if (mLteRsrp >= -115) levelLteRsrp = SIGNAL_STRENGTH_POOR; 575 else levelLteRsrp = 0; 576 577 if (DBG) log("Lte level: "+levelLteRsrp); 578 return levelLteRsrp; 579 } 580 581 /** 582 * Get the LTE signal level as an asu value between 0..97, 99 is unknown 583 * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69 584 * 585 * @hide 586 */ 587 public int getLteAsuLevel() { 588 int lteAsuLevel = 99; 589 int lteDbm = getLteDbm(); 590 if (lteDbm <= -140) lteAsuLevel = 0; 591 else if (lteDbm >= -43) lteAsuLevel = 97; 592 else lteAsuLevel = lteDbm + 140; 593 if (DBG) log("Lte Asu level: "+lteAsuLevel); 594 return lteAsuLevel; 595 } 596 597 /** 598 * @return true if this is for GSM 599 */ 600 public boolean isGsm() { 601 return this.isGsm; 602 } 603 604 /** 605 * @return hash code 606 */ 607 @Override 608 public int hashCode() { 609 int primeNum = 31; 610 return ((mGsmSignalStrength * primeNum) 611 + (mGsmBitErrorRate * primeNum) 612 + (mCdmaDbm * primeNum) + (mCdmaEcio * primeNum) 613 + (mEvdoDbm * primeNum) + (mEvdoEcio * primeNum) + (mEvdoSnr * primeNum) 614 + (mLteSignalStrength * primeNum) + (mLteRsrp * primeNum) 615 + (mLteRsrq * primeNum) + (mLteRssnr * primeNum) + (mLteCqi * primeNum) 616 + (isGsm ? 1 : 0)); 617 } 618 619 /** 620 * @return true if the signal strengths are the same 621 */ 622 @Override 623 public boolean equals (Object o) { 624 SignalStrength s; 625 626 try { 627 s = (SignalStrength) o; 628 } catch (ClassCastException ex) { 629 return false; 630 } 631 632 if (o == null) { 633 return false; 634 } 635 636 return (mGsmSignalStrength == s.mGsmSignalStrength 637 && mGsmBitErrorRate == s.mGsmBitErrorRate 638 && mCdmaDbm == s.mCdmaDbm 639 && mCdmaEcio == s.mCdmaEcio 640 && mEvdoDbm == s.mEvdoDbm 641 && mEvdoEcio == s.mEvdoEcio 642 && mEvdoSnr == s.mEvdoSnr 643 && mLteSignalStrength == s.mLteSignalStrength 644 && mLteRsrp == s.mLteRsrp 645 && mLteRsrq == s.mLteRsrq 646 && mLteRssnr == s.mLteRssnr 647 && mLteCqi == s.mLteCqi 648 && isGsm == s.isGsm); 649 } 650 651 /** 652 * @return string representation. 653 */ 654 @Override 655 public String toString() { 656 return ("SignalStrength:" 657 + " " + mGsmSignalStrength 658 + " " + mGsmBitErrorRate 659 + " " + mCdmaDbm 660 + " " + mCdmaEcio 661 + " " + mEvdoDbm 662 + " " + mEvdoEcio 663 + " " + mEvdoSnr 664 + " " + mLteSignalStrength 665 + " " + mLteRsrp 666 + " " + mLteRsrq 667 + " " + mLteRssnr 668 + " " + mLteCqi 669 + " " + (isGsm ? "gsm|lte" : "cdma")); 670 } 671 672 /** 673 * Set SignalStrength based on intent notifier map 674 * 675 * @param m intent notifier map 676 * @hide 677 */ 678 private void setFromNotifierBundle(Bundle m) { 679 mGsmSignalStrength = m.getInt("GsmSignalStrength"); 680 mGsmBitErrorRate = m.getInt("GsmBitErrorRate"); 681 mCdmaDbm = m.getInt("CdmaDbm"); 682 mCdmaEcio = m.getInt("CdmaEcio"); 683 mEvdoDbm = m.getInt("EvdoDbm"); 684 mEvdoEcio = m.getInt("EvdoEcio"); 685 mEvdoSnr = m.getInt("EvdoSnr"); 686 mLteSignalStrength = m.getInt("LteSignalStrength"); 687 mLteRsrp = m.getInt("LteRsrp"); 688 mLteRsrq = m.getInt("LteRsrq"); 689 mLteRssnr = m.getInt("LteRssnr"); 690 mLteCqi = m.getInt("LteCqi"); 691 isGsm = m.getBoolean("isGsm"); 692 } 693 694 /** 695 * Set intent notifier Bundle based on SignalStrength 696 * 697 * @param m intent notifier Bundle 698 * @hide 699 */ 700 public void fillInNotifierBundle(Bundle m) { 701 m.putInt("GsmSignalStrength", mGsmSignalStrength); 702 m.putInt("GsmBitErrorRate", mGsmBitErrorRate); 703 m.putInt("CdmaDbm", mCdmaDbm); 704 m.putInt("CdmaEcio", mCdmaEcio); 705 m.putInt("EvdoDbm", mEvdoDbm); 706 m.putInt("EvdoEcio", mEvdoEcio); 707 m.putInt("EvdoSnr", mEvdoSnr); 708 m.putInt("LteSignalStrength", mLteSignalStrength); 709 m.putInt("LteRsrp", mLteRsrp); 710 m.putInt("LteRsrq", mLteRsrq); 711 m.putInt("LteRssnr", mLteRssnr); 712 m.putInt("LteCqi", mLteCqi); 713 m.putBoolean("isGsm", Boolean.valueOf(isGsm)); 714 } 715 716 /** 717 * log 718 */ 719 private static void log(String s) { 720 Log.w(LOG_TAG, s); 721 } 722 } 723
