1 /* 2 * Copyright (C) 2006 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.Bundle; 20 import android.os.Parcel; 21 import android.os.Parcelable; 22 import android.telephony.Rlog; 23 24 /** 25 * Contains phone state and service related information. 26 * 27 * The following phone information is included in returned ServiceState: 28 * 29 * <ul> 30 * <li>Service state: IN_SERVICE, OUT_OF_SERVICE, EMERGENCY_ONLY, POWER_OFF 31 * <li>Roaming indicator 32 * <li>Operator name, short name and numeric id 33 * <li>Network selection mode 34 * </ul> 35 */ 36 public class ServiceState implements Parcelable { 37 38 static final String LOG_TAG = "PHONE"; 39 static final boolean DBG = true; 40 41 /** 42 * Normal operation condition, the phone is registered 43 * with an operator either in home network or in roaming. 44 */ 45 public static final int STATE_IN_SERVICE = 0; 46 47 /** 48 * Phone is not registered with any operator, the phone 49 * can be currently searching a new operator to register to, or not 50 * searching to registration at all, or registration is denied, or radio 51 * signal is not available. 52 */ 53 public static final int STATE_OUT_OF_SERVICE = 1; 54 55 /** 56 * The phone is registered and locked. Only emergency numbers are allowed. {@more} 57 */ 58 public static final int STATE_EMERGENCY_ONLY = 2; 59 60 /** 61 * Radio of telephony is explicitly powered off. 62 */ 63 public static final int STATE_POWER_OFF = 3; 64 65 /** 66 * RIL level registration state values from ril.h 67 * ((const char **)response)[0] is registration state 0-6, 68 * 0 - Not registered, MT is not currently searching 69 * a new operator to register 70 * 1 - Registered, home network 71 * 2 - Not registered, but MT is currently searching 72 * a new operator to register 73 * 3 - Registration denied 74 * 4 - Unknown 75 * 5 - Registered, roaming 76 * 10 - Same as 0, but indicates that emergency calls 77 * are enabled. 78 * 12 - Same as 2, but indicates that emergency calls 79 * are enabled. 80 * 13 - Same as 3, but indicates that emergency calls 81 * are enabled. 82 * 14 - Same as 4, but indicates that emergency calls 83 * are enabled. 84 * @hide 85 */ 86 public static final int RIL_REG_STATE_NOT_REG = 0; 87 /** @hide */ 88 public static final int RIL_REG_STATE_HOME = 1; 89 /** @hide */ 90 public static final int RIL_REG_STATE_SEARCHING = 2; 91 /** @hide */ 92 public static final int RIL_REG_STATE_DENIED = 3; 93 /** @hide */ 94 public static final int RIL_REG_STATE_UNKNOWN = 4; 95 /** @hide */ 96 public static final int RIL_REG_STATE_ROAMING = 5; 97 /** @hide */ 98 public static final int RIL_REG_STATE_NOT_REG_EMERGENCY_CALL_ENABLED = 10; 99 /** @hide */ 100 public static final int RIL_REG_STATE_SEARCHING_EMERGENCY_CALL_ENABLED = 12; 101 /** @hide */ 102 public static final int RIL_REG_STATE_DENIED_EMERGENCY_CALL_ENABLED = 13; 103 /** @hide */ 104 public static final int RIL_REG_STATE_UNKNOWN_EMERGENCY_CALL_ENABLED = 14; 105 106 /** 107 * Available radio technologies for GSM, UMTS and CDMA. 108 * Duplicates the constants from hardware/radio/include/ril.h 109 * This should only be used by agents working with the ril. Others 110 * should use the equivalent TelephonyManager.NETWORK_TYPE_* 111 */ 112 /** @hide */ 113 public static final int RIL_RADIO_TECHNOLOGY_UNKNOWN = 0; 114 /** @hide */ 115 public static final int RIL_RADIO_TECHNOLOGY_GPRS = 1; 116 /** @hide */ 117 public static final int RIL_RADIO_TECHNOLOGY_EDGE = 2; 118 /** @hide */ 119 public static final int RIL_RADIO_TECHNOLOGY_UMTS = 3; 120 /** @hide */ 121 public static final int RIL_RADIO_TECHNOLOGY_IS95A = 4; 122 /** @hide */ 123 public static final int RIL_RADIO_TECHNOLOGY_IS95B = 5; 124 /** @hide */ 125 public static final int RIL_RADIO_TECHNOLOGY_1xRTT = 6; 126 /** @hide */ 127 public static final int RIL_RADIO_TECHNOLOGY_EVDO_0 = 7; 128 /** @hide */ 129 public static final int RIL_RADIO_TECHNOLOGY_EVDO_A = 8; 130 /** @hide */ 131 public static final int RIL_RADIO_TECHNOLOGY_HSDPA = 9; 132 /** @hide */ 133 public static final int RIL_RADIO_TECHNOLOGY_HSUPA = 10; 134 /** @hide */ 135 public static final int RIL_RADIO_TECHNOLOGY_HSPA = 11; 136 /** @hide */ 137 public static final int RIL_RADIO_TECHNOLOGY_EVDO_B = 12; 138 /** @hide */ 139 public static final int RIL_RADIO_TECHNOLOGY_EHRPD = 13; 140 /** @hide */ 141 public static final int RIL_RADIO_TECHNOLOGY_LTE = 14; 142 /** @hide */ 143 public static final int RIL_RADIO_TECHNOLOGY_HSPAP = 15; 144 /** 145 * GSM radio technology only supports voice. It does not support data. 146 * @hide 147 */ 148 public static final int RIL_RADIO_TECHNOLOGY_GSM = 16; 149 150 /** 151 * Available registration states for GSM, UMTS and CDMA. 152 */ 153 /** @hide */ 154 public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING = 0; 155 /** @hide */ 156 public static final int REGISTRATION_STATE_HOME_NETWORK = 1; 157 /** @hide */ 158 public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_SEARCHING = 2; 159 /** @hide */ 160 public static final int REGISTRATION_STATE_REGISTRATION_DENIED = 3; 161 /** @hide */ 162 public static final int REGISTRATION_STATE_UNKNOWN = 4; 163 /** @hide */ 164 public static final int REGISTRATION_STATE_ROAMING = 5; 165 166 private int mVoiceRegState = STATE_OUT_OF_SERVICE; 167 private int mDataRegState = STATE_OUT_OF_SERVICE; 168 private boolean mRoaming; 169 private String mOperatorAlphaLong; 170 private String mOperatorAlphaShort; 171 private String mOperatorNumeric; 172 private boolean mIsManualNetworkSelection; 173 174 private boolean mIsEmergencyOnly; 175 176 private int mRilVoiceRadioTechnology; 177 private int mRilDataRadioTechnology; 178 179 private boolean mCssIndicator; 180 private int mNetworkId; 181 private int mSystemId; 182 private int mCdmaRoamingIndicator; 183 private int mCdmaDefaultRoamingIndicator; 184 private int mCdmaEriIconIndex; 185 private int mCdmaEriIconMode; 186 187 /** 188 * Create a new ServiceState from a intent notifier Bundle 189 * 190 * This method is used by PhoneStateIntentReceiver and maybe by 191 * external applications. 192 * 193 * @param m Bundle from intent notifier 194 * @return newly created ServiceState 195 * @hide 196 */ 197 public static ServiceState newFromBundle(Bundle m) { 198 ServiceState ret; 199 ret = new ServiceState(); 200 ret.setFromNotifierBundle(m); 201 return ret; 202 } 203 204 /** 205 * Empty constructor 206 */ 207 public ServiceState() { 208 } 209 210 /** 211 * Copy constructors 212 * 213 * @param s Source service state 214 */ 215 public ServiceState(ServiceState s) { 216 copyFrom(s); 217 } 218 219 protected void copyFrom(ServiceState s) { 220 mVoiceRegState = s.mVoiceRegState; 221 mDataRegState = s.mDataRegState; 222 mRoaming = s.mRoaming; 223 mOperatorAlphaLong = s.mOperatorAlphaLong; 224 mOperatorAlphaShort = s.mOperatorAlphaShort; 225 mOperatorNumeric = s.mOperatorNumeric; 226 mIsManualNetworkSelection = s.mIsManualNetworkSelection; 227 mRilVoiceRadioTechnology = s.mRilVoiceRadioTechnology; 228 mRilDataRadioTechnology = s.mRilDataRadioTechnology; 229 mCssIndicator = s.mCssIndicator; 230 mNetworkId = s.mNetworkId; 231 mSystemId = s.mSystemId; 232 mCdmaRoamingIndicator = s.mCdmaRoamingIndicator; 233 mCdmaDefaultRoamingIndicator = s.mCdmaDefaultRoamingIndicator; 234 mCdmaEriIconIndex = s.mCdmaEriIconIndex; 235 mCdmaEriIconMode = s.mCdmaEriIconMode; 236 mIsEmergencyOnly = s.mIsEmergencyOnly; 237 } 238 239 /** 240 * Construct a ServiceState object from the given parcel. 241 */ 242 public ServiceState(Parcel in) { 243 mVoiceRegState = in.readInt(); 244 mDataRegState = in.readInt(); 245 mRoaming = in.readInt() != 0; 246 mOperatorAlphaLong = in.readString(); 247 mOperatorAlphaShort = in.readString(); 248 mOperatorNumeric = in.readString(); 249 mIsManualNetworkSelection = in.readInt() != 0; 250 mRilVoiceRadioTechnology = in.readInt(); 251 mRilDataRadioTechnology = in.readInt(); 252 mCssIndicator = (in.readInt() != 0); 253 mNetworkId = in.readInt(); 254 mSystemId = in.readInt(); 255 mCdmaRoamingIndicator = in.readInt(); 256 mCdmaDefaultRoamingIndicator = in.readInt(); 257 mCdmaEriIconIndex = in.readInt(); 258 mCdmaEriIconMode = in.readInt(); 259 mIsEmergencyOnly = in.readInt() != 0; 260 } 261 262 public void writeToParcel(Parcel out, int flags) { 263 out.writeInt(mVoiceRegState); 264 out.writeInt(mDataRegState); 265 out.writeInt(mRoaming ? 1 : 0); 266 out.writeString(mOperatorAlphaLong); 267 out.writeString(mOperatorAlphaShort); 268 out.writeString(mOperatorNumeric); 269 out.writeInt(mIsManualNetworkSelection ? 1 : 0); 270 out.writeInt(mRilVoiceRadioTechnology); 271 out.writeInt(mRilDataRadioTechnology); 272 out.writeInt(mCssIndicator ? 1 : 0); 273 out.writeInt(mNetworkId); 274 out.writeInt(mSystemId); 275 out.writeInt(mCdmaRoamingIndicator); 276 out.writeInt(mCdmaDefaultRoamingIndicator); 277 out.writeInt(mCdmaEriIconIndex); 278 out.writeInt(mCdmaEriIconMode); 279 out.writeInt(mIsEmergencyOnly ? 1 : 0); 280 } 281 282 public int describeContents() { 283 return 0; 284 } 285 286 public static final Parcelable.Creator<ServiceState> CREATOR = 287 new Parcelable.Creator<ServiceState>() { 288 public ServiceState createFromParcel(Parcel in) { 289 return new ServiceState(in); 290 } 291 292 public ServiceState[] newArray(int size) { 293 return new ServiceState[size]; 294 } 295 }; 296 297 /** 298 * Get current voice service state 299 */ 300 public int getState() { 301 return getVoiceRegState(); 302 } 303 304 /** 305 * Get current voice service state 306 * 307 * @see #STATE_IN_SERVICE 308 * @see #STATE_OUT_OF_SERVICE 309 * @see #STATE_EMERGENCY_ONLY 310 * @see #STATE_POWER_OFF 311 * 312 * @hide 313 */ 314 public int getVoiceRegState() { 315 return mVoiceRegState; 316 } 317 318 /** 319 * Get current data service state 320 * 321 * @see #STATE_IN_SERVICE 322 * @see #STATE_OUT_OF_SERVICE 323 * @see #STATE_EMERGENCY_ONLY 324 * @see #STATE_POWER_OFF 325 * 326 * @hide 327 */ 328 public int getDataRegState() { 329 return mDataRegState; 330 } 331 332 /** 333 * Get current roaming indicator of phone 334 * (note: not just decoding from TS 27.007 7.2) 335 * 336 * @return true if TS 27.007 7.2 roaming is true 337 * and ONS is different from SPN 338 * 339 */ 340 public boolean getRoaming() { 341 return mRoaming; 342 } 343 344 /** 345 * @hide 346 */ 347 public boolean isEmergencyOnly() { 348 return mIsEmergencyOnly; 349 } 350 351 /** 352 * @hide 353 */ 354 public int getCdmaRoamingIndicator(){ 355 return this.mCdmaRoamingIndicator; 356 } 357 358 /** 359 * @hide 360 */ 361 public int getCdmaDefaultRoamingIndicator(){ 362 return this.mCdmaDefaultRoamingIndicator; 363 } 364 365 /** 366 * @hide 367 */ 368 public int getCdmaEriIconIndex() { 369 return this.mCdmaEriIconIndex; 370 } 371 372 /** 373 * @hide 374 */ 375 public int getCdmaEriIconMode() { 376 return this.mCdmaEriIconMode; 377 } 378 379 /** 380 * Get current registered operator name in long alphanumeric format. 381 * 382 * In GSM/UMTS, long format can be up to 16 characters long. 383 * In CDMA, returns the ERI text, if set. Otherwise, returns the ONS. 384 * 385 * @return long name of operator, null if unregistered or unknown 386 */ 387 public String getOperatorAlphaLong() { 388 return mOperatorAlphaLong; 389 } 390 391 /** 392 * Get current registered operator name in short alphanumeric format. 393 * 394 * In GSM/UMTS, short format can be up to 8 characters long. 395 * 396 * @return short name of operator, null if unregistered or unknown 397 */ 398 public String getOperatorAlphaShort() { 399 return mOperatorAlphaShort; 400 } 401 402 /** 403 * Get current registered operator numeric id. 404 * 405 * In GSM/UMTS, numeric format is 3 digit country code plus 2 or 3 digit 406 * network code. 407 * 408 * @return numeric format of operator, null if unregistered or unknown 409 */ 410 /* 411 * The country code can be decoded using 412 * {@link com.android.internal.telephony.MccTable#countryCodeForMcc(int)}. 413 */ 414 public String getOperatorNumeric() { 415 return mOperatorNumeric; 416 } 417 418 /** 419 * Get current network selection mode. 420 * 421 * @return true if manual mode, false if automatic mode 422 */ 423 public boolean getIsManualSelection() { 424 return mIsManualNetworkSelection; 425 } 426 427 @Override 428 public int hashCode() { 429 return ((mVoiceRegState * 31) 430 + (mDataRegState * 37) 431 + (mRoaming ? 1 : 0) 432 + (mIsManualNetworkSelection ? 1 : 0) 433 + ((null == mOperatorAlphaLong) ? 0 : mOperatorAlphaLong.hashCode()) 434 + ((null == mOperatorAlphaShort) ? 0 : mOperatorAlphaShort.hashCode()) 435 + ((null == mOperatorNumeric) ? 0 : mOperatorNumeric.hashCode()) 436 + mCdmaRoamingIndicator 437 + mCdmaDefaultRoamingIndicator 438 + (mIsEmergencyOnly ? 1 : 0)); 439 } 440 441 @Override 442 public boolean equals (Object o) { 443 ServiceState s; 444 445 try { 446 s = (ServiceState) o; 447 } catch (ClassCastException ex) { 448 return false; 449 } 450 451 if (o == null) { 452 return false; 453 } 454 455 return (mVoiceRegState == s.mVoiceRegState 456 && mDataRegState == s.mDataRegState 457 && mRoaming == s.mRoaming 458 && mIsManualNetworkSelection == s.mIsManualNetworkSelection 459 && equalsHandlesNulls(mOperatorAlphaLong, s.mOperatorAlphaLong) 460 && equalsHandlesNulls(mOperatorAlphaShort, s.mOperatorAlphaShort) 461 && equalsHandlesNulls(mOperatorNumeric, s.mOperatorNumeric) 462 && equalsHandlesNulls(mRilVoiceRadioTechnology, s.mRilVoiceRadioTechnology) 463 && equalsHandlesNulls(mRilDataRadioTechnology, s.mRilDataRadioTechnology) 464 && equalsHandlesNulls(mCssIndicator, s.mCssIndicator) 465 && equalsHandlesNulls(mNetworkId, s.mNetworkId) 466 && equalsHandlesNulls(mSystemId, s.mSystemId) 467 && equalsHandlesNulls(mCdmaRoamingIndicator, s.mCdmaRoamingIndicator) 468 && equalsHandlesNulls(mCdmaDefaultRoamingIndicator, 469 s.mCdmaDefaultRoamingIndicator) 470 && mIsEmergencyOnly == s.mIsEmergencyOnly); 471 } 472 473 /** 474 * Convert radio technology to String 475 * 476 * @param radioTechnology 477 * @return String representation of the RAT 478 * 479 * @hide 480 */ 481 public static String rilRadioTechnologyToString(int rt) { 482 String rtString; 483 484 switch(rt) { 485 case RIL_RADIO_TECHNOLOGY_UNKNOWN: 486 rtString = "Unknown"; 487 break; 488 case RIL_RADIO_TECHNOLOGY_GPRS: 489 rtString = "GPRS"; 490 break; 491 case RIL_RADIO_TECHNOLOGY_EDGE: 492 rtString = "EDGE"; 493 break; 494 case RIL_RADIO_TECHNOLOGY_UMTS: 495 rtString = "UMTS"; 496 break; 497 case RIL_RADIO_TECHNOLOGY_IS95A: 498 rtString = "CDMA-IS95A"; 499 break; 500 case RIL_RADIO_TECHNOLOGY_IS95B: 501 rtString = "CDMA-IS95B"; 502 break; 503 case RIL_RADIO_TECHNOLOGY_1xRTT: 504 rtString = "1xRTT"; 505 break; 506 case RIL_RADIO_TECHNOLOGY_EVDO_0: 507 rtString = "EvDo-rev.0"; 508 break; 509 case RIL_RADIO_TECHNOLOGY_EVDO_A: 510 rtString = "EvDo-rev.A"; 511 break; 512 case RIL_RADIO_TECHNOLOGY_HSDPA: 513 rtString = "HSDPA"; 514 break; 515 case RIL_RADIO_TECHNOLOGY_HSUPA: 516 rtString = "HSUPA"; 517 break; 518 case RIL_RADIO_TECHNOLOGY_HSPA: 519 rtString = "HSPA"; 520 break; 521 case RIL_RADIO_TECHNOLOGY_EVDO_B: 522 rtString = "EvDo-rev.B"; 523 break; 524 case RIL_RADIO_TECHNOLOGY_EHRPD: 525 rtString = "eHRPD"; 526 break; 527 case RIL_RADIO_TECHNOLOGY_LTE: 528 rtString = "LTE"; 529 break; 530 case RIL_RADIO_TECHNOLOGY_HSPAP: 531 rtString = "HSPAP"; 532 break; 533 case RIL_RADIO_TECHNOLOGY_GSM: 534 rtString = "GSM"; 535 break; 536 default: 537 rtString = "Unexpected"; 538 Rlog.w(LOG_TAG, "Unexpected radioTechnology=" + rt); 539 break; 540 } 541 return rtString; 542 } 543 544 @Override 545 public String toString() { 546 String radioTechnology = rilRadioTechnologyToString(mRilVoiceRadioTechnology); 547 String dataRadioTechnology = rilRadioTechnologyToString(mRilDataRadioTechnology); 548 549 return (mVoiceRegState + " " + mDataRegState + " " + (mRoaming ? "roaming" : "home") 550 + " " + mOperatorAlphaLong 551 + " " + mOperatorAlphaShort 552 + " " + mOperatorNumeric 553 + " " + (mIsManualNetworkSelection ? "(manual)" : "") 554 + " " + radioTechnology 555 + " " + dataRadioTechnology 556 + " " + (mCssIndicator ? "CSS supported" : "CSS not supported") 557 + " " + mNetworkId 558 + " " + mSystemId 559 + " RoamInd=" + mCdmaRoamingIndicator 560 + " DefRoamInd=" + mCdmaDefaultRoamingIndicator 561 + " EmergOnly=" + mIsEmergencyOnly); 562 } 563 564 private void setNullState(int state) { 565 if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setNullState=" + state); 566 mVoiceRegState = state; 567 mDataRegState = state; 568 mRoaming = false; 569 mOperatorAlphaLong = null; 570 mOperatorAlphaShort = null; 571 mOperatorNumeric = null; 572 mIsManualNetworkSelection = false; 573 mRilVoiceRadioTechnology = 0; 574 mRilDataRadioTechnology = 0; 575 mCssIndicator = false; 576 mNetworkId = -1; 577 mSystemId = -1; 578 mCdmaRoamingIndicator = -1; 579 mCdmaDefaultRoamingIndicator = -1; 580 mCdmaEriIconIndex = -1; 581 mCdmaEriIconMode = -1; 582 mIsEmergencyOnly = false; 583 } 584 585 public void setStateOutOfService() { 586 setNullState(STATE_OUT_OF_SERVICE); 587 } 588 589 public void setStateOff() { 590 setNullState(STATE_POWER_OFF); 591 } 592 593 public void setState(int state) { 594 setVoiceRegState(state); 595 if (DBG) Rlog.e(LOG_TAG, "[ServiceState] setState deprecated use setVoiceRegState()"); 596 } 597 598 /** @hide */ 599 public void setVoiceRegState(int state) { 600 mVoiceRegState = state; 601 if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setVoiceRegState=" + mVoiceRegState); 602 } 603 604 /** @hide */ 605 public void setDataRegState(int state) { 606 mDataRegState = state; 607 if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setDataRegState=" + mDataRegState); 608 } 609 610 public void setRoaming(boolean roaming) { 611 mRoaming = roaming; 612 } 613 614 615 /** 616 * @hide 617 */ 618 public void setEmergencyOnly(boolean emergencyOnly) { 619 mIsEmergencyOnly = emergencyOnly; 620 } 621 622 /** 623 * @hide 624 */ 625 public void setCdmaRoamingIndicator(int roaming) { 626 this.mCdmaRoamingIndicator = roaming; 627 } 628 629 /** 630 * @hide 631 */ 632 public void setCdmaDefaultRoamingIndicator (int roaming) { 633 this.mCdmaDefaultRoamingIndicator = roaming; 634 } 635 636 /** 637 * @hide 638 */ 639 public void setCdmaEriIconIndex(int index) { 640 this.mCdmaEriIconIndex = index; 641 } 642 643 /** 644 * @hide 645 */ 646 public void setCdmaEriIconMode(int mode) { 647 this.mCdmaEriIconMode = mode; 648 } 649 650 public void setOperatorName(String longName, String shortName, String numeric) { 651 mOperatorAlphaLong = longName; 652 mOperatorAlphaShort = shortName; 653 mOperatorNumeric = numeric; 654 } 655 656 /** 657 * In CDMA, mOperatorAlphaLong can be set from the ERI text. 658 * This is done from the CDMAPhone and not from the CdmaServiceStateTracker. 659 * 660 * @hide 661 */ 662 public void setOperatorAlphaLong(String longName) { 663 mOperatorAlphaLong = longName; 664 } 665 666 public void setIsManualSelection(boolean isManual) { 667 mIsManualNetworkSelection = isManual; 668 } 669 670 /** 671 * Test whether two objects hold the same data values or both are null. 672 * 673 * @param a first obj 674 * @param b second obj 675 * @return true if two objects equal or both are null 676 */ 677 private static boolean equalsHandlesNulls (Object a, Object b) { 678 return (a == null) ? (b == null) : a.equals (b); 679 } 680 681 /** 682 * Set ServiceState based on intent notifier map. 683 * 684 * @param m intent notifier map 685 * @hide 686 */ 687 private void setFromNotifierBundle(Bundle m) { 688 mVoiceRegState = m.getInt("voiceRegState"); 689 mDataRegState = m.getInt("dataRegState"); 690 mRoaming = m.getBoolean("roaming"); 691 mOperatorAlphaLong = m.getString("operator-alpha-long"); 692 mOperatorAlphaShort = m.getString("operator-alpha-short"); 693 mOperatorNumeric = m.getString("operator-numeric"); 694 mIsManualNetworkSelection = m.getBoolean("manual"); 695 mRilVoiceRadioTechnology = m.getInt("radioTechnology"); 696 mRilVoiceRadioTechnology = m.getInt("dataRadioTechnology"); 697 mCssIndicator = m.getBoolean("cssIndicator"); 698 mNetworkId = m.getInt("networkId"); 699 mSystemId = m.getInt("systemId"); 700 mCdmaRoamingIndicator = m.getInt("cdmaRoamingIndicator"); 701 mCdmaDefaultRoamingIndicator = m.getInt("cdmaDefaultRoamingIndicator"); 702 mIsEmergencyOnly = m.getBoolean("emergencyOnly"); 703 } 704 705 /** 706 * Set intent notifier Bundle based on service state. 707 * 708 * @param m intent notifier Bundle 709 * @hide 710 */ 711 public void fillInNotifierBundle(Bundle m) { 712 m.putInt("voiceRegState", mVoiceRegState); 713 m.putInt("dataRegState", mDataRegState); 714 m.putBoolean("roaming", Boolean.valueOf(mRoaming)); 715 m.putString("operator-alpha-long", mOperatorAlphaLong); 716 m.putString("operator-alpha-short", mOperatorAlphaShort); 717 m.putString("operator-numeric", mOperatorNumeric); 718 m.putBoolean("manual", Boolean.valueOf(mIsManualNetworkSelection)); 719 m.putInt("radioTechnology", mRilVoiceRadioTechnology); 720 m.putInt("dataRadioTechnology", mRilDataRadioTechnology); 721 m.putBoolean("cssIndicator", mCssIndicator); 722 m.putInt("networkId", mNetworkId); 723 m.putInt("systemId", mSystemId); 724 m.putInt("cdmaRoamingIndicator", mCdmaRoamingIndicator); 725 m.putInt("cdmaDefaultRoamingIndicator", mCdmaDefaultRoamingIndicator); 726 m.putBoolean("emergencyOnly", Boolean.valueOf(mIsEmergencyOnly)); 727 } 728 729 /** @hide */ 730 public void setRilVoiceRadioTechnology(int rt) { 731 this.mRilVoiceRadioTechnology = rt; 732 } 733 734 /** @hide */ 735 public void setRilDataRadioTechnology(int rt) { 736 this.mRilDataRadioTechnology = rt; 737 if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setDataRadioTechnology=" + mRilDataRadioTechnology); 738 } 739 740 /** @hide */ 741 public void setCssIndicator(int css) { 742 this.mCssIndicator = (css != 0); 743 } 744 745 /** @hide */ 746 public void setSystemAndNetworkId(int systemId, int networkId) { 747 this.mSystemId = systemId; 748 this.mNetworkId = networkId; 749 } 750 751 /** @hide */ 752 public int getRilVoiceRadioTechnology() { 753 return this.mRilVoiceRadioTechnology; 754 } 755 /** @hide */ 756 public int getRilDataRadioTechnology() { 757 return this.mRilDataRadioTechnology; 758 } 759 /** 760 * @hide 761 * @Deprecated to be removed Q3 2013 use {@link #getRilDataRadioTechnology} or 762 * {@link #getRilVoiceRadioTechnology} 763 */ 764 public int getRadioTechnology() { 765 Rlog.e(LOG_TAG, "ServiceState.getRadioTechnology() DEPRECATED will be removed *******"); 766 return getRilDataRadioTechnology(); 767 } 768 769 private int rilRadioTechnologyToNetworkType(int rt) { 770 switch(rt) { 771 case ServiceState.RIL_RADIO_TECHNOLOGY_GPRS: 772 return TelephonyManager.NETWORK_TYPE_GPRS; 773 case ServiceState.RIL_RADIO_TECHNOLOGY_EDGE: 774 return TelephonyManager.NETWORK_TYPE_EDGE; 775 case ServiceState.RIL_RADIO_TECHNOLOGY_UMTS: 776 return TelephonyManager.NETWORK_TYPE_UMTS; 777 case ServiceState.RIL_RADIO_TECHNOLOGY_HSDPA: 778 return TelephonyManager.NETWORK_TYPE_HSDPA; 779 case ServiceState.RIL_RADIO_TECHNOLOGY_HSUPA: 780 return TelephonyManager.NETWORK_TYPE_HSUPA; 781 case ServiceState.RIL_RADIO_TECHNOLOGY_HSPA: 782 return TelephonyManager.NETWORK_TYPE_HSPA; 783 case ServiceState.RIL_RADIO_TECHNOLOGY_IS95A: 784 case ServiceState.RIL_RADIO_TECHNOLOGY_IS95B: 785 return TelephonyManager.NETWORK_TYPE_CDMA; 786 case ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT: 787 return TelephonyManager.NETWORK_TYPE_1xRTT; 788 case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0: 789 return TelephonyManager.NETWORK_TYPE_EVDO_0; 790 case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_A: 791 return TelephonyManager.NETWORK_TYPE_EVDO_A; 792 case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_B: 793 return TelephonyManager.NETWORK_TYPE_EVDO_B; 794 case ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD: 795 return TelephonyManager.NETWORK_TYPE_EHRPD; 796 case ServiceState.RIL_RADIO_TECHNOLOGY_LTE: 797 return TelephonyManager.NETWORK_TYPE_LTE; 798 case ServiceState.RIL_RADIO_TECHNOLOGY_HSPAP: 799 return TelephonyManager.NETWORK_TYPE_HSPAP; 800 default: 801 return TelephonyManager.NETWORK_TYPE_UNKNOWN; 802 } 803 } 804 805 /** 806 * @Deprecated to be removed Q3 2013 use {@link #getVoiceNetworkType} 807 * @hide 808 */ 809 public int getNetworkType() { 810 Rlog.e(LOG_TAG, "ServiceState.getNetworkType() DEPRECATED will be removed *******"); 811 return rilRadioTechnologyToNetworkType(mRilVoiceRadioTechnology); 812 } 813 814 /** @hide */ 815 public int getDataNetworkType() { 816 return rilRadioTechnologyToNetworkType(mRilDataRadioTechnology); 817 } 818 819 /** @hide */ 820 public int getVoiceNetworkType() { 821 return rilRadioTechnologyToNetworkType(mRilVoiceRadioTechnology); 822 } 823 824 /** @hide */ 825 public int getCssIndicator() { 826 return this.mCssIndicator ? 1 : 0; 827 } 828 829 /** @hide */ 830 public int getNetworkId() { 831 return this.mNetworkId; 832 } 833 834 /** @hide */ 835 public int getSystemId() { 836 return this.mSystemId; 837 } 838 839 /** @hide */ 840 public static boolean isGsm(int radioTechnology) { 841 return radioTechnology == RIL_RADIO_TECHNOLOGY_GPRS 842 || radioTechnology == RIL_RADIO_TECHNOLOGY_EDGE 843 || radioTechnology == RIL_RADIO_TECHNOLOGY_UMTS 844 || radioTechnology == RIL_RADIO_TECHNOLOGY_HSDPA 845 || radioTechnology == RIL_RADIO_TECHNOLOGY_HSUPA 846 || radioTechnology == RIL_RADIO_TECHNOLOGY_HSPA 847 || radioTechnology == RIL_RADIO_TECHNOLOGY_LTE 848 || radioTechnology == RIL_RADIO_TECHNOLOGY_HSPAP 849 || radioTechnology == RIL_RADIO_TECHNOLOGY_GSM; 850 } 851 852 /** @hide */ 853 public static boolean isCdma(int radioTechnology) { 854 return radioTechnology == RIL_RADIO_TECHNOLOGY_IS95A 855 || radioTechnology == RIL_RADIO_TECHNOLOGY_IS95B 856 || radioTechnology == RIL_RADIO_TECHNOLOGY_1xRTT 857 || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_0 858 || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_A 859 || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_B 860 || radioTechnology == RIL_RADIO_TECHNOLOGY_EHRPD; 861 } 862 } 863
