TelephonyManager.java revision 0dde2c20a07770bc2f1b21e49222c968f3d8b39a
1/* 2 * Copyright (C) 2008 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 17package android.telephony; 18 19import android.annotation.SdkConstant; 20import android.annotation.SdkConstant.SdkConstantType; 21import android.content.Context; 22import android.os.Bundle; 23import android.os.RemoteException; 24import android.os.ServiceManager; 25import android.os.SystemProperties; 26import android.util.Log; 27 28import com.android.internal.telephony.IPhoneSubInfo; 29import com.android.internal.telephony.ITelephony; 30import com.android.internal.telephony.ITelephonyRegistry; 31import com.android.internal.telephony.PhoneConstants; 32import com.android.internal.telephony.RILConstants; 33import com.android.internal.telephony.TelephonyProperties; 34 35import java.io.FileInputStream; 36import java.io.IOException; 37import java.util.List; 38import java.util.regex.Matcher; 39import java.util.regex.Pattern; 40 41/** 42 * Provides access to information about the telephony services on 43 * the device. Applications can use the methods in this class to 44 * determine telephony services and states, as well as to access some 45 * types of subscriber information. Applications can also register 46 * a listener to receive notification of telephony state changes. 47 * <p> 48 * You do not instantiate this class directly; instead, you retrieve 49 * a reference to an instance through 50 * {@link android.content.Context#getSystemService 51 * Context.getSystemService(Context.TELEPHONY_SERVICE)}. 52 * <p> 53 * Note that access to some telephony information is 54 * permission-protected. Your application cannot access the protected 55 * information unless it has the appropriate permissions declared in 56 * its manifest file. Where permissions apply, they are noted in the 57 * the methods through which you access the protected information. 58 */ 59public class TelephonyManager { 60 private static final String TAG = "TelephonyManager"; 61 62 private static Context sContext; 63 private static ITelephonyRegistry sRegistry; 64 65 /** @hide */ 66 public TelephonyManager(Context context) { 67 if (sContext == null) { 68 Context appContext = context.getApplicationContext(); 69 if (appContext != null) { 70 sContext = appContext; 71 } else { 72 sContext = context; 73 } 74 75 sRegistry = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService( 76 "telephony.registry")); 77 } 78 } 79 80 /** @hide */ 81 private TelephonyManager() { 82 } 83 84 private static TelephonyManager sInstance = new TelephonyManager(); 85 86 /** @hide 87 /* @deprecated - use getSystemService as described above */ 88 public static TelephonyManager getDefault() { 89 return sInstance; 90 } 91 92 /** {@hide} */ 93 public static TelephonyManager from(Context context) { 94 return (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 95 } 96 97 // 98 // Broadcast Intent actions 99 // 100 101 /** 102 * Broadcast intent action indicating that the call state (cellular) 103 * on the device has changed. 104 * 105 * <p> 106 * The {@link #EXTRA_STATE} extra indicates the new call state. 107 * If the new state is RINGING, a second extra 108 * {@link #EXTRA_INCOMING_NUMBER} provides the incoming phone number as 109 * a String. 110 * 111 * <p class="note"> 112 * Requires the READ_PHONE_STATE permission. 113 * 114 * <p class="note"> 115 * This was a {@link android.content.Context#sendStickyBroadcast sticky} 116 * broadcast in version 1.0, but it is no longer sticky. 117 * Instead, use {@link #getCallState} to synchronously query the current call state. 118 * 119 * @see #EXTRA_STATE 120 * @see #EXTRA_INCOMING_NUMBER 121 * @see #getCallState 122 */ 123 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 124 public static final String ACTION_PHONE_STATE_CHANGED = 125 "android.intent.action.PHONE_STATE"; 126 127 /** 128 * The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast 129 * for a String containing the new call state. 130 * 131 * @see #EXTRA_STATE_IDLE 132 * @see #EXTRA_STATE_RINGING 133 * @see #EXTRA_STATE_OFFHOOK 134 * 135 * <p class="note"> 136 * Retrieve with 137 * {@link android.content.Intent#getStringExtra(String)}. 138 */ 139 public static final String EXTRA_STATE = PhoneConstants.STATE_KEY; 140 141 /** 142 * Value used with {@link #EXTRA_STATE} corresponding to 143 * {@link #CALL_STATE_IDLE}. 144 */ 145 public static final String EXTRA_STATE_IDLE = PhoneConstants.State.IDLE.toString(); 146 147 /** 148 * Value used with {@link #EXTRA_STATE} corresponding to 149 * {@link #CALL_STATE_RINGING}. 150 */ 151 public static final String EXTRA_STATE_RINGING = PhoneConstants.State.RINGING.toString(); 152 153 /** 154 * Value used with {@link #EXTRA_STATE} corresponding to 155 * {@link #CALL_STATE_OFFHOOK}. 156 */ 157 public static final String EXTRA_STATE_OFFHOOK = PhoneConstants.State.OFFHOOK.toString(); 158 159 /** 160 * The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast 161 * for a String containing the incoming phone number. 162 * Only valid when the new call state is RINGING. 163 * 164 * <p class="note"> 165 * Retrieve with 166 * {@link android.content.Intent#getStringExtra(String)}. 167 */ 168 public static final String EXTRA_INCOMING_NUMBER = "incoming_number"; 169 170 171 // 172 // 173 // Device Info 174 // 175 // 176 177 /** 178 * Returns the software version number for the device, for example, 179 * the IMEI/SV for GSM phones. Return null if the software version is 180 * not available. 181 * 182 * <p>Requires Permission: 183 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 184 */ 185 public String getDeviceSoftwareVersion() { 186 try { 187 return getSubscriberInfo().getDeviceSvn(); 188 } catch (RemoteException ex) { 189 return null; 190 } catch (NullPointerException ex) { 191 return null; 192 } 193 } 194 195 /** 196 * Returns the unique device ID, for example, the IMEI for GSM and the MEID 197 * or ESN for CDMA phones. Return null if device ID is not available. 198 * 199 * <p>Requires Permission: 200 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 201 */ 202 public String getDeviceId() { 203 try { 204 return getSubscriberInfo().getDeviceId(); 205 } catch (RemoteException ex) { 206 return null; 207 } catch (NullPointerException ex) { 208 return null; 209 } 210 } 211 212 /** 213 * Returns the current location of the device. 214 * Return null if current location is not available. 215 * 216 * <p>Requires Permission: 217 * {@link android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_COARSE_LOCATION} or 218 * {@link android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_FINE_LOCATION}. 219 */ 220 public CellLocation getCellLocation() { 221 try { 222 Bundle bundle = getITelephony().getCellLocation(); 223 if (bundle.isEmpty()) return null; 224 CellLocation cl = CellLocation.newFromBundle(bundle); 225 if (cl.isEmpty()) 226 return null; 227 return cl; 228 } catch (RemoteException ex) { 229 return null; 230 } catch (NullPointerException ex) { 231 return null; 232 } 233 } 234 235 /** 236 * Enables location update notifications. {@link PhoneStateListener#onCellLocationChanged 237 * PhoneStateListener.onCellLocationChanged} will be called on location updates. 238 * 239 * <p>Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES 240 * CONTROL_LOCATION_UPDATES} 241 * 242 * @hide 243 */ 244 public void enableLocationUpdates() { 245 try { 246 getITelephony().enableLocationUpdates(); 247 } catch (RemoteException ex) { 248 } catch (NullPointerException ex) { 249 } 250 } 251 252 /** 253 * Disables location update notifications. {@link PhoneStateListener#onCellLocationChanged 254 * PhoneStateListener.onCellLocationChanged} will be called on location updates. 255 * 256 * <p>Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES 257 * CONTROL_LOCATION_UPDATES} 258 * 259 * @hide 260 */ 261 public void disableLocationUpdates() { 262 try { 263 getITelephony().disableLocationUpdates(); 264 } catch (RemoteException ex) { 265 } catch (NullPointerException ex) { 266 } 267 } 268 269 /** 270 * Returns the neighboring cell information of the device. 271 * 272 * @return List of NeighboringCellInfo or null if info unavailable. 273 * 274 * <p>Requires Permission: 275 * (@link android.Manifest.permission#ACCESS_COARSE_UPDATES} 276 */ 277 public List<NeighboringCellInfo> getNeighboringCellInfo() { 278 try { 279 return getITelephony().getNeighboringCellInfo(); 280 } catch (RemoteException ex) { 281 return null; 282 } catch (NullPointerException ex) { 283 return null; 284 } 285 } 286 287 /** No phone radio. */ 288 public static final int PHONE_TYPE_NONE = PhoneConstants.PHONE_TYPE_NONE; 289 /** Phone radio is GSM. */ 290 public static final int PHONE_TYPE_GSM = PhoneConstants.PHONE_TYPE_GSM; 291 /** Phone radio is CDMA. */ 292 public static final int PHONE_TYPE_CDMA = PhoneConstants.PHONE_TYPE_CDMA; 293 /** Phone is via SIP. */ 294 public static final int PHONE_TYPE_SIP = PhoneConstants.PHONE_TYPE_SIP; 295 296 /** 297 * Returns the current phone type. 298 * TODO: This is a last minute change and hence hidden. 299 * 300 * @see #PHONE_TYPE_NONE 301 * @see #PHONE_TYPE_GSM 302 * @see #PHONE_TYPE_CDMA 303 * @see #PHONE_TYPE_SIP 304 * 305 * {@hide} 306 */ 307 public int getCurrentPhoneType() { 308 try{ 309 ITelephony telephony = getITelephony(); 310 if (telephony != null) { 311 return telephony.getActivePhoneType(); 312 } else { 313 // This can happen when the ITelephony interface is not up yet. 314 return getPhoneTypeFromProperty(); 315 } 316 } catch (RemoteException ex) { 317 // This shouldn't happen in the normal case, as a backup we 318 // read from the system property. 319 return getPhoneTypeFromProperty(); 320 } catch (NullPointerException ex) { 321 // This shouldn't happen in the normal case, as a backup we 322 // read from the system property. 323 return getPhoneTypeFromProperty(); 324 } 325 } 326 327 /** 328 * Returns a constant indicating the device phone type. This 329 * indicates the type of radio used to transmit voice calls. 330 * 331 * @see #PHONE_TYPE_NONE 332 * @see #PHONE_TYPE_GSM 333 * @see #PHONE_TYPE_CDMA 334 * @see #PHONE_TYPE_SIP 335 */ 336 public int getPhoneType() { 337 if (!isVoiceCapable()) { 338 return PHONE_TYPE_NONE; 339 } 340 return getCurrentPhoneType(); 341 } 342 343 private int getPhoneTypeFromProperty() { 344 int type = 345 SystemProperties.getInt(TelephonyProperties.CURRENT_ACTIVE_PHONE, 346 getPhoneTypeFromNetworkType()); 347 return type; 348 } 349 350 private int getPhoneTypeFromNetworkType() { 351 // When the system property CURRENT_ACTIVE_PHONE, has not been set, 352 // use the system property for default network type. 353 // This is a fail safe, and can only happen at first boot. 354 int mode = SystemProperties.getInt("ro.telephony.default_network", -1); 355 if (mode == -1) 356 return PHONE_TYPE_NONE; 357 return getPhoneType(mode); 358 } 359 360 /** 361 * This function returns the type of the phone, depending 362 * on the network mode. 363 * 364 * @param network mode 365 * @return Phone Type 366 * 367 * @hide 368 */ 369 public static int getPhoneType(int networkMode) { 370 switch(networkMode) { 371 case RILConstants.NETWORK_MODE_CDMA: 372 case RILConstants.NETWORK_MODE_CDMA_NO_EVDO: 373 case RILConstants.NETWORK_MODE_EVDO_NO_CDMA: 374 return PhoneConstants.PHONE_TYPE_CDMA; 375 376 case RILConstants.NETWORK_MODE_WCDMA_PREF: 377 case RILConstants.NETWORK_MODE_GSM_ONLY: 378 case RILConstants.NETWORK_MODE_WCDMA_ONLY: 379 case RILConstants.NETWORK_MODE_GSM_UMTS: 380 return PhoneConstants.PHONE_TYPE_GSM; 381 382 // Use CDMA Phone for the global mode including CDMA 383 case RILConstants.NETWORK_MODE_GLOBAL: 384 case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO: 385 case RILConstants.NETWORK_MODE_LTE_CMDA_EVDO_GSM_WCDMA: 386 return PhoneConstants.PHONE_TYPE_CDMA; 387 388 case RILConstants.NETWORK_MODE_LTE_ONLY: 389 if (getLteOnCdmaModeStatic() == PhoneConstants.LTE_ON_CDMA_TRUE) { 390 return PhoneConstants.PHONE_TYPE_CDMA; 391 } else { 392 return PhoneConstants.PHONE_TYPE_GSM; 393 } 394 default: 395 return PhoneConstants.PHONE_TYPE_GSM; 396 } 397 } 398 399 /** 400 * The contents of the /proc/cmdline file 401 */ 402 private static String getProcCmdLine() 403 { 404 String cmdline = ""; 405 FileInputStream is = null; 406 try { 407 is = new FileInputStream("/proc/cmdline"); 408 byte [] buffer = new byte[2048]; 409 int count = is.read(buffer); 410 if (count > 0) { 411 cmdline = new String(buffer, 0, count); 412 } 413 } catch (IOException e) { 414 Log.d(TAG, "No /proc/cmdline exception=" + e); 415 } finally { 416 if (is != null) { 417 try { 418 is.close(); 419 } catch (IOException e) { 420 } 421 } 422 } 423 Log.d(TAG, "/proc/cmdline=" + cmdline); 424 return cmdline; 425 } 426 427 /** Kernel command line */ 428 private static final String sKernelCmdLine = getProcCmdLine(); 429 430 /** Pattern for selecting the product type from the kernel command line */ 431 private static final Pattern sProductTypePattern = 432 Pattern.compile("\\sproduct_type\\s*=\\s*(\\w+)"); 433 434 /** The ProductType used for LTE on CDMA devices */ 435 private static final String sLteOnCdmaProductType = 436 SystemProperties.get(TelephonyProperties.PROPERTY_LTE_ON_CDMA_PRODUCT_TYPE, ""); 437 438 /** 439 * Return if the current radio is LTE on CDMA. This 440 * is a tri-state return value as for a period of time 441 * the mode may be unknown. 442 * 443 * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE} 444 * or {@link PhoneConstants#LTE_ON_CDMA_TRUE} 445 * 446 * @hide 447 */ 448 public static int getLteOnCdmaModeStatic() { 449 int retVal; 450 int curVal; 451 String productType = ""; 452 453 curVal = SystemProperties.getInt(TelephonyProperties.PROPERTY_LTE_ON_CDMA_DEVICE, 454 PhoneConstants.LTE_ON_CDMA_UNKNOWN); 455 retVal = curVal; 456 if (retVal == PhoneConstants.LTE_ON_CDMA_UNKNOWN) { 457 Matcher matcher = sProductTypePattern.matcher(sKernelCmdLine); 458 if (matcher.find()) { 459 productType = matcher.group(1); 460 if (sLteOnCdmaProductType.equals(productType)) { 461 retVal = PhoneConstants.LTE_ON_CDMA_TRUE; 462 } else { 463 retVal = PhoneConstants.LTE_ON_CDMA_FALSE; 464 } 465 } else { 466 retVal = PhoneConstants.LTE_ON_CDMA_FALSE; 467 } 468 } 469 470 Log.d(TAG, "getLteOnCdmaMode=" + retVal + " curVal=" + curVal + 471 " product_type='" + productType + 472 "' lteOnCdmaProductType='" + sLteOnCdmaProductType + "'"); 473 return retVal; 474 } 475 476 // 477 // 478 // Current Network 479 // 480 // 481 482 /** 483 * Returns the alphabetic name of current registered operator. 484 * <p> 485 * Availability: Only when user is registered to a network. Result may be 486 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 487 * on a CDMA network). 488 */ 489 public String getNetworkOperatorName() { 490 return SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ALPHA); 491 } 492 493 /** 494 * Returns the numeric name (MCC+MNC) of current registered operator. 495 * <p> 496 * Availability: Only when user is registered to a network. Result may be 497 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 498 * on a CDMA network). 499 */ 500 public String getNetworkOperator() { 501 return SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC); 502 } 503 504 /** 505 * Returns true if the device is considered roaming on the current 506 * network, for GSM purposes. 507 * <p> 508 * Availability: Only when user registered to a network. 509 */ 510 public boolean isNetworkRoaming() { 511 return "true".equals(SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING)); 512 } 513 514 /** 515 * Returns the ISO country code equivalent of the current registered 516 * operator's MCC (Mobile Country Code). 517 * <p> 518 * Availability: Only when user is registered to a network. Result may be 519 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 520 * on a CDMA network). 521 */ 522 public String getNetworkCountryIso() { 523 return SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY); 524 } 525 526 /** Network type is unknown */ 527 public static final int NETWORK_TYPE_UNKNOWN = 0; 528 /** Current network is GPRS */ 529 public static final int NETWORK_TYPE_GPRS = 1; 530 /** Current network is EDGE */ 531 public static final int NETWORK_TYPE_EDGE = 2; 532 /** Current network is UMTS */ 533 public static final int NETWORK_TYPE_UMTS = 3; 534 /** Current network is CDMA: Either IS95A or IS95B*/ 535 public static final int NETWORK_TYPE_CDMA = 4; 536 /** Current network is EVDO revision 0*/ 537 public static final int NETWORK_TYPE_EVDO_0 = 5; 538 /** Current network is EVDO revision A*/ 539 public static final int NETWORK_TYPE_EVDO_A = 6; 540 /** Current network is 1xRTT*/ 541 public static final int NETWORK_TYPE_1xRTT = 7; 542 /** Current network is HSDPA */ 543 public static final int NETWORK_TYPE_HSDPA = 8; 544 /** Current network is HSUPA */ 545 public static final int NETWORK_TYPE_HSUPA = 9; 546 /** Current network is HSPA */ 547 public static final int NETWORK_TYPE_HSPA = 10; 548 /** Current network is iDen */ 549 public static final int NETWORK_TYPE_IDEN = 11; 550 /** Current network is EVDO revision B*/ 551 public static final int NETWORK_TYPE_EVDO_B = 12; 552 /** Current network is LTE */ 553 public static final int NETWORK_TYPE_LTE = 13; 554 /** Current network is eHRPD */ 555 public static final int NETWORK_TYPE_EHRPD = 14; 556 /** Current network is HSPA+ */ 557 public static final int NETWORK_TYPE_HSPAP = 15; 558 559 /** 560 * Returns the NETWORK_TYPE_xxxx for data transmission 561 */ 562 public int getNetworkType() { 563 return getDataNetworkType(); 564 } 565 566 /** 567 * Returns a constant indicating the radio technology (network type) 568 * currently in use on the device for data transmission. 569 * @return the network type 570 * 571 * @see #NETWORK_TYPE_UNKNOWN 572 * @see #NETWORK_TYPE_GPRS 573 * @see #NETWORK_TYPE_EDGE 574 * @see #NETWORK_TYPE_UMTS 575 * @see #NETWORK_TYPE_HSDPA 576 * @see #NETWORK_TYPE_HSUPA 577 * @see #NETWORK_TYPE_HSPA 578 * @see #NETWORK_TYPE_CDMA 579 * @see #NETWORK_TYPE_EVDO_0 580 * @see #NETWORK_TYPE_EVDO_A 581 * @see #NETWORK_TYPE_EVDO_B 582 * @see #NETWORK_TYPE_1xRTT 583 * @see #NETWORK_TYPE_IDEN 584 * @see #NETWORK_TYPE_LTE 585 * @see #NETWORK_TYPE_EHRPD 586 * @see #NETWORK_TYPE_HSPAP 587 * 588 * @hide 589 */ 590 public int getDataNetworkType() { 591 try{ 592 ITelephony telephony = getITelephony(); 593 if (telephony != null) { 594 return telephony.getDataNetworkType(); 595 } else { 596 // This can happen when the ITelephony interface is not up yet. 597 return NETWORK_TYPE_UNKNOWN; 598 } 599 } catch(RemoteException ex) { 600 // This shouldn't happen in the normal case 601 return NETWORK_TYPE_UNKNOWN; 602 } catch (NullPointerException ex) { 603 // This could happen before phone restarts due to crashing 604 return NETWORK_TYPE_UNKNOWN; 605 } 606 } 607 608 /** 609 * Returns the NETWORK_TYPE_xxxx for voice 610 * 611 * @hide 612 */ 613 public int getVoiceNetworkType() { 614 try{ 615 ITelephony telephony = getITelephony(); 616 if (telephony != null) { 617 return telephony.getVoiceNetworkType(); 618 } else { 619 // This can happen when the ITelephony interface is not up yet. 620 return NETWORK_TYPE_UNKNOWN; 621 } 622 } catch(RemoteException ex) { 623 // This shouldn't happen in the normal case 624 return NETWORK_TYPE_UNKNOWN; 625 } catch (NullPointerException ex) { 626 // This could happen before phone restarts due to crashing 627 return NETWORK_TYPE_UNKNOWN; 628 } 629 } 630 631 /** Unknown network class. {@hide} */ 632 public static final int NETWORK_CLASS_UNKNOWN = 0; 633 /** Class of broadly defined "2G" networks. {@hide} */ 634 public static final int NETWORK_CLASS_2_G = 1; 635 /** Class of broadly defined "3G" networks. {@hide} */ 636 public static final int NETWORK_CLASS_3_G = 2; 637 /** Class of broadly defined "4G" networks. {@hide} */ 638 public static final int NETWORK_CLASS_4_G = 3; 639 640 /** 641 * Return general class of network type, such as "3G" or "4G". In cases 642 * where classification is contentious, this method is conservative. 643 * 644 * @hide 645 */ 646 public static int getNetworkClass(int networkType) { 647 switch (networkType) { 648 case NETWORK_TYPE_GPRS: 649 case NETWORK_TYPE_EDGE: 650 case NETWORK_TYPE_CDMA: 651 case NETWORK_TYPE_1xRTT: 652 case NETWORK_TYPE_IDEN: 653 return NETWORK_CLASS_2_G; 654 case NETWORK_TYPE_UMTS: 655 case NETWORK_TYPE_EVDO_0: 656 case NETWORK_TYPE_EVDO_A: 657 case NETWORK_TYPE_HSDPA: 658 case NETWORK_TYPE_HSUPA: 659 case NETWORK_TYPE_HSPA: 660 case NETWORK_TYPE_EVDO_B: 661 case NETWORK_TYPE_EHRPD: 662 case NETWORK_TYPE_HSPAP: 663 return NETWORK_CLASS_3_G; 664 case NETWORK_TYPE_LTE: 665 return NETWORK_CLASS_4_G; 666 default: 667 return NETWORK_CLASS_UNKNOWN; 668 } 669 } 670 671 /** 672 * Returns a string representation of the radio technology (network type) 673 * currently in use on the device. 674 * @return the name of the radio technology 675 * 676 * @hide pending API council review 677 */ 678 public String getNetworkTypeName() { 679 return getNetworkTypeName(getNetworkType()); 680 } 681 682 /** {@hide} */ 683 public static String getNetworkTypeName(int type) { 684 switch (type) { 685 case NETWORK_TYPE_GPRS: 686 return "GPRS"; 687 case NETWORK_TYPE_EDGE: 688 return "EDGE"; 689 case NETWORK_TYPE_UMTS: 690 return "UMTS"; 691 case NETWORK_TYPE_HSDPA: 692 return "HSDPA"; 693 case NETWORK_TYPE_HSUPA: 694 return "HSUPA"; 695 case NETWORK_TYPE_HSPA: 696 return "HSPA"; 697 case NETWORK_TYPE_CDMA: 698 return "CDMA"; 699 case NETWORK_TYPE_EVDO_0: 700 return "CDMA - EvDo rev. 0"; 701 case NETWORK_TYPE_EVDO_A: 702 return "CDMA - EvDo rev. A"; 703 case NETWORK_TYPE_EVDO_B: 704 return "CDMA - EvDo rev. B"; 705 case NETWORK_TYPE_1xRTT: 706 return "CDMA - 1xRTT"; 707 case NETWORK_TYPE_LTE: 708 return "LTE"; 709 case NETWORK_TYPE_EHRPD: 710 return "CDMA - eHRPD"; 711 case NETWORK_TYPE_IDEN: 712 return "iDEN"; 713 case NETWORK_TYPE_HSPAP: 714 return "HSPA+"; 715 default: 716 return "UNKNOWN"; 717 } 718 } 719 720 // 721 // 722 // SIM Card 723 // 724 // 725 726 /** SIM card state: Unknown. Signifies that the SIM is in transition 727 * between states. For example, when the user inputs the SIM pin 728 * under PIN_REQUIRED state, a query for sim status returns 729 * this state before turning to SIM_STATE_READY. */ 730 public static final int SIM_STATE_UNKNOWN = 0; 731 /** SIM card state: no SIM card is available in the device */ 732 public static final int SIM_STATE_ABSENT = 1; 733 /** SIM card state: Locked: requires the user's SIM PIN to unlock */ 734 public static final int SIM_STATE_PIN_REQUIRED = 2; 735 /** SIM card state: Locked: requires the user's SIM PUK to unlock */ 736 public static final int SIM_STATE_PUK_REQUIRED = 3; 737 /** SIM card state: Locked: requries a network PIN to unlock */ 738 public static final int SIM_STATE_NETWORK_LOCKED = 4; 739 /** SIM card state: Ready */ 740 public static final int SIM_STATE_READY = 5; 741 742 /** 743 * @return true if a ICC card is present 744 */ 745 public boolean hasIccCard() { 746 try { 747 return getITelephony().hasIccCard(); 748 } catch (RemoteException ex) { 749 // Assume no ICC card if remote exception which shouldn't happen 750 return false; 751 } catch (NullPointerException ex) { 752 // This could happen before phone restarts due to crashing 753 return false; 754 } 755 } 756 757 /** 758 * Returns a constant indicating the state of the 759 * device SIM card. 760 * 761 * @see #SIM_STATE_UNKNOWN 762 * @see #SIM_STATE_ABSENT 763 * @see #SIM_STATE_PIN_REQUIRED 764 * @see #SIM_STATE_PUK_REQUIRED 765 * @see #SIM_STATE_NETWORK_LOCKED 766 * @see #SIM_STATE_READY 767 */ 768 public int getSimState() { 769 String prop = SystemProperties.get(TelephonyProperties.PROPERTY_SIM_STATE); 770 if ("ABSENT".equals(prop)) { 771 return SIM_STATE_ABSENT; 772 } 773 else if ("PIN_REQUIRED".equals(prop)) { 774 return SIM_STATE_PIN_REQUIRED; 775 } 776 else if ("PUK_REQUIRED".equals(prop)) { 777 return SIM_STATE_PUK_REQUIRED; 778 } 779 else if ("NETWORK_LOCKED".equals(prop)) { 780 return SIM_STATE_NETWORK_LOCKED; 781 } 782 else if ("READY".equals(prop)) { 783 return SIM_STATE_READY; 784 } 785 else { 786 return SIM_STATE_UNKNOWN; 787 } 788 } 789 790 /** 791 * Returns the MCC+MNC (mobile country code + mobile network code) of the 792 * provider of the SIM. 5 or 6 decimal digits. 793 * <p> 794 * Availability: SIM state must be {@link #SIM_STATE_READY} 795 * 796 * @see #getSimState 797 */ 798 public String getSimOperator() { 799 return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC); 800 } 801 802 /** 803 * Returns the Service Provider Name (SPN). 804 * <p> 805 * Availability: SIM state must be {@link #SIM_STATE_READY} 806 * 807 * @see #getSimState 808 */ 809 public String getSimOperatorName() { 810 return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA); 811 } 812 813 /** 814 * Returns the ISO country code equivalent for the SIM provider's country code. 815 */ 816 public String getSimCountryIso() { 817 return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY); 818 } 819 820 /** 821 * Returns the serial number of the SIM, if applicable. Return null if it is 822 * unavailable. 823 * <p> 824 * Requires Permission: 825 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 826 */ 827 public String getSimSerialNumber() { 828 try { 829 return getSubscriberInfo().getIccSerialNumber(); 830 } catch (RemoteException ex) { 831 return null; 832 } catch (NullPointerException ex) { 833 // This could happen before phone restarts due to crashing 834 return null; 835 } 836 } 837 838 /** 839 * Return if the current radio is LTE on CDMA. This 840 * is a tri-state return value as for a period of time 841 * the mode may be unknown. 842 * 843 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE} 844 * or {@link Phone#LTE_ON_CDMA_TRUE} 845 * 846 * @hide 847 */ 848 public int getLteOnCdmaMode() { 849 try { 850 return getITelephony().getLteOnCdmaMode(); 851 } catch (RemoteException ex) { 852 // Assume no ICC card if remote exception which shouldn't happen 853 return PhoneConstants.LTE_ON_CDMA_UNKNOWN; 854 } catch (NullPointerException ex) { 855 // This could happen before phone restarts due to crashing 856 return PhoneConstants.LTE_ON_CDMA_UNKNOWN; 857 } 858 } 859 860 // 861 // 862 // Subscriber Info 863 // 864 // 865 866 /** 867 * Returns the unique subscriber ID, for example, the IMSI for a GSM phone. 868 * Return null if it is unavailable. 869 * <p> 870 * Requires Permission: 871 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 872 */ 873 public String getSubscriberId() { 874 try { 875 return getSubscriberInfo().getSubscriberId(); 876 } catch (RemoteException ex) { 877 return null; 878 } catch (NullPointerException ex) { 879 // This could happen before phone restarts due to crashing 880 return null; 881 } 882 } 883 884 /** 885 * Returns the phone number string for line 1, for example, the MSISDN 886 * for a GSM phone. Return null if it is unavailable. 887 * <p> 888 * Requires Permission: 889 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 890 */ 891 public String getLine1Number() { 892 try { 893 return getSubscriberInfo().getLine1Number(); 894 } catch (RemoteException ex) { 895 return null; 896 } catch (NullPointerException ex) { 897 // This could happen before phone restarts due to crashing 898 return null; 899 } 900 } 901 902 /** 903 * Returns the alphabetic identifier associated with the line 1 number. 904 * Return null if it is unavailable. 905 * <p> 906 * Requires Permission: 907 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 908 * @hide 909 * nobody seems to call this. 910 */ 911 public String getLine1AlphaTag() { 912 try { 913 return getSubscriberInfo().getLine1AlphaTag(); 914 } catch (RemoteException ex) { 915 return null; 916 } catch (NullPointerException ex) { 917 // This could happen before phone restarts due to crashing 918 return null; 919 } 920 } 921 922 /** 923 * Returns the MSISDN string. 924 * for a GSM phone. Return null if it is unavailable. 925 * <p> 926 * Requires Permission: 927 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 928 * 929 * @hide 930 */ 931 public String getMsisdn() { 932 try { 933 return getSubscriberInfo().getMsisdn(); 934 } catch (RemoteException ex) { 935 return null; 936 } catch (NullPointerException ex) { 937 // This could happen before phone restarts due to crashing 938 return null; 939 } 940 } 941 942 /** 943 * Returns the voice mail number. Return null if it is unavailable. 944 * <p> 945 * Requires Permission: 946 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 947 */ 948 public String getVoiceMailNumber() { 949 try { 950 return getSubscriberInfo().getVoiceMailNumber(); 951 } catch (RemoteException ex) { 952 return null; 953 } catch (NullPointerException ex) { 954 // This could happen before phone restarts due to crashing 955 return null; 956 } 957 } 958 959 /** 960 * Returns the complete voice mail number. Return null if it is unavailable. 961 * <p> 962 * Requires Permission: 963 * {@link android.Manifest.permission#CALL_PRIVILEGED CALL_PRIVILEGED} 964 * 965 * @hide 966 */ 967 public String getCompleteVoiceMailNumber() { 968 try { 969 return getSubscriberInfo().getCompleteVoiceMailNumber(); 970 } catch (RemoteException ex) { 971 return null; 972 } catch (NullPointerException ex) { 973 // This could happen before phone restarts due to crashing 974 return null; 975 } 976 } 977 978 /** 979 * Returns the voice mail count. Return 0 if unavailable. 980 * <p> 981 * Requires Permission: 982 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 983 * @hide 984 */ 985 public int getVoiceMessageCount() { 986 try { 987 return getITelephony().getVoiceMessageCount(); 988 } catch (RemoteException ex) { 989 return 0; 990 } catch (NullPointerException ex) { 991 // This could happen before phone restarts due to crashing 992 return 0; 993 } 994 } 995 996 /** 997 * Retrieves the alphabetic identifier associated with the voice 998 * mail number. 999 * <p> 1000 * Requires Permission: 1001 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1002 */ 1003 public String getVoiceMailAlphaTag() { 1004 try { 1005 return getSubscriberInfo().getVoiceMailAlphaTag(); 1006 } catch (RemoteException ex) { 1007 return null; 1008 } catch (NullPointerException ex) { 1009 // This could happen before phone restarts due to crashing 1010 return null; 1011 } 1012 } 1013 1014 /** 1015 * Returns the IMS private user identity (IMPI) that was loaded from the ISIM. 1016 * @return the IMPI, or null if not present or not loaded 1017 * @hide 1018 */ 1019 public String getIsimImpi() { 1020 try { 1021 return getSubscriberInfo().getIsimImpi(); 1022 } catch (RemoteException ex) { 1023 return null; 1024 } catch (NullPointerException ex) { 1025 // This could happen before phone restarts due to crashing 1026 return null; 1027 } 1028 } 1029 1030 /** 1031 * Returns the IMS home network domain name that was loaded from the ISIM. 1032 * @return the IMS domain name, or null if not present or not loaded 1033 * @hide 1034 */ 1035 public String getIsimDomain() { 1036 try { 1037 return getSubscriberInfo().getIsimDomain(); 1038 } catch (RemoteException ex) { 1039 return null; 1040 } catch (NullPointerException ex) { 1041 // This could happen before phone restarts due to crashing 1042 return null; 1043 } 1044 } 1045 1046 /** 1047 * Returns the IMS public user identities (IMPU) that were loaded from the ISIM. 1048 * @return an array of IMPU strings, with one IMPU per string, or null if 1049 * not present or not loaded 1050 * @hide 1051 */ 1052 public String[] getIsimImpu() { 1053 try { 1054 return getSubscriberInfo().getIsimImpu(); 1055 } catch (RemoteException ex) { 1056 return null; 1057 } catch (NullPointerException ex) { 1058 // This could happen before phone restarts due to crashing 1059 return null; 1060 } 1061 } 1062 1063 private IPhoneSubInfo getSubscriberInfo() { 1064 // get it each time because that process crashes a lot 1065 return IPhoneSubInfo.Stub.asInterface(ServiceManager.getService("iphonesubinfo")); 1066 } 1067 1068 1069 /** Device call state: No activity. */ 1070 public static final int CALL_STATE_IDLE = 0; 1071 /** Device call state: Ringing. A new call arrived and is 1072 * ringing or waiting. In the latter case, another call is 1073 * already active. */ 1074 public static final int CALL_STATE_RINGING = 1; 1075 /** Device call state: Off-hook. At least one call exists 1076 * that is dialing, active, or on hold, and no calls are ringing 1077 * or waiting. */ 1078 public static final int CALL_STATE_OFFHOOK = 2; 1079 1080 /** 1081 * Returns a constant indicating the call state (cellular) on the device. 1082 */ 1083 public int getCallState() { 1084 try { 1085 return getITelephony().getCallState(); 1086 } catch (RemoteException ex) { 1087 // the phone process is restarting. 1088 return CALL_STATE_IDLE; 1089 } catch (NullPointerException ex) { 1090 // the phone process is restarting. 1091 return CALL_STATE_IDLE; 1092 } 1093 } 1094 1095 /** Data connection activity: No traffic. */ 1096 public static final int DATA_ACTIVITY_NONE = 0x00000000; 1097 /** Data connection activity: Currently receiving IP PPP traffic. */ 1098 public static final int DATA_ACTIVITY_IN = 0x00000001; 1099 /** Data connection activity: Currently sending IP PPP traffic. */ 1100 public static final int DATA_ACTIVITY_OUT = 0x00000002; 1101 /** Data connection activity: Currently both sending and receiving 1102 * IP PPP traffic. */ 1103 public static final int DATA_ACTIVITY_INOUT = DATA_ACTIVITY_IN | DATA_ACTIVITY_OUT; 1104 /** 1105 * Data connection is active, but physical link is down 1106 */ 1107 public static final int DATA_ACTIVITY_DORMANT = 0x00000004; 1108 1109 /** 1110 * Returns a constant indicating the type of activity on a data connection 1111 * (cellular). 1112 * 1113 * @see #DATA_ACTIVITY_NONE 1114 * @see #DATA_ACTIVITY_IN 1115 * @see #DATA_ACTIVITY_OUT 1116 * @see #DATA_ACTIVITY_INOUT 1117 * @see #DATA_ACTIVITY_DORMANT 1118 */ 1119 public int getDataActivity() { 1120 try { 1121 return getITelephony().getDataActivity(); 1122 } catch (RemoteException ex) { 1123 // the phone process is restarting. 1124 return DATA_ACTIVITY_NONE; 1125 } catch (NullPointerException ex) { 1126 // the phone process is restarting. 1127 return DATA_ACTIVITY_NONE; 1128 } 1129 } 1130 1131 /** Data connection state: Unknown. Used before we know the state. 1132 * @hide 1133 */ 1134 public static final int DATA_UNKNOWN = -1; 1135 /** Data connection state: Disconnected. IP traffic not available. */ 1136 public static final int DATA_DISCONNECTED = 0; 1137 /** Data connection state: Currently setting up a data connection. */ 1138 public static final int DATA_CONNECTING = 1; 1139 /** Data connection state: Connected. IP traffic should be available. */ 1140 public static final int DATA_CONNECTED = 2; 1141 /** Data connection state: Suspended. The connection is up, but IP 1142 * traffic is temporarily unavailable. For example, in a 2G network, 1143 * data activity may be suspended when a voice call arrives. */ 1144 public static final int DATA_SUSPENDED = 3; 1145 1146 /** 1147 * Returns a constant indicating the current data connection state 1148 * (cellular). 1149 * 1150 * @see #DATA_DISCONNECTED 1151 * @see #DATA_CONNECTING 1152 * @see #DATA_CONNECTED 1153 * @see #DATA_SUSPENDED 1154 */ 1155 public int getDataState() { 1156 try { 1157 return getITelephony().getDataState(); 1158 } catch (RemoteException ex) { 1159 // the phone process is restarting. 1160 return DATA_DISCONNECTED; 1161 } catch (NullPointerException ex) { 1162 return DATA_DISCONNECTED; 1163 } 1164 } 1165 1166 private ITelephony getITelephony() { 1167 return ITelephony.Stub.asInterface(ServiceManager.getService(Context.TELEPHONY_SERVICE)); 1168 } 1169 1170 // 1171 // 1172 // PhoneStateListener 1173 // 1174 // 1175 1176 /** 1177 * Registers a listener object to receive notification of changes 1178 * in specified telephony states. 1179 * <p> 1180 * To register a listener, pass a {@link PhoneStateListener} 1181 * and specify at least one telephony state of interest in 1182 * the events argument. 1183 * 1184 * At registration, and when a specified telephony state 1185 * changes, the telephony manager invokes the appropriate 1186 * callback method on the listener object and passes the 1187 * current (udpated) values. 1188 * <p> 1189 * To unregister a listener, pass the listener object and set the 1190 * events argument to 1191 * {@link PhoneStateListener#LISTEN_NONE LISTEN_NONE} (0). 1192 * 1193 * @param listener The {@link PhoneStateListener} object to register 1194 * (or unregister) 1195 * @param events The telephony state(s) of interest to the listener, 1196 * as a bitwise-OR combination of {@link PhoneStateListener} 1197 * LISTEN_ flags. 1198 */ 1199 public void listen(PhoneStateListener listener, int events) { 1200 String pkgForDebug = sContext != null ? sContext.getPackageName() : "<unknown>"; 1201 try { 1202 Boolean notifyNow = (getITelephony() != null); 1203 sRegistry.listen(pkgForDebug, listener.callback, events, notifyNow); 1204 } catch (RemoteException ex) { 1205 // system process dead 1206 } catch (NullPointerException ex) { 1207 // system process dead 1208 } 1209 } 1210 1211 /** 1212 * Returns the CDMA ERI icon index to display 1213 * 1214 * @hide 1215 */ 1216 public int getCdmaEriIconIndex() { 1217 try { 1218 return getITelephony().getCdmaEriIconIndex(); 1219 } catch (RemoteException ex) { 1220 // the phone process is restarting. 1221 return -1; 1222 } catch (NullPointerException ex) { 1223 return -1; 1224 } 1225 } 1226 1227 /** 1228 * Returns the CDMA ERI icon mode, 1229 * 0 - ON 1230 * 1 - FLASHING 1231 * 1232 * @hide 1233 */ 1234 public int getCdmaEriIconMode() { 1235 try { 1236 return getITelephony().getCdmaEriIconMode(); 1237 } catch (RemoteException ex) { 1238 // the phone process is restarting. 1239 return -1; 1240 } catch (NullPointerException ex) { 1241 return -1; 1242 } 1243 } 1244 1245 /** 1246 * Returns the CDMA ERI text, 1247 * 1248 * @hide 1249 */ 1250 public String getCdmaEriText() { 1251 try { 1252 return getITelephony().getCdmaEriText(); 1253 } catch (RemoteException ex) { 1254 // the phone process is restarting. 1255 return null; 1256 } catch (NullPointerException ex) { 1257 return null; 1258 } 1259 } 1260 1261 /** 1262 * @return true if the current device is "voice capable". 1263 * <p> 1264 * "Voice capable" means that this device supports circuit-switched 1265 * (i.e. voice) phone calls over the telephony network, and is allowed 1266 * to display the in-call UI while a cellular voice call is active. 1267 * This will be false on "data only" devices which can't make voice 1268 * calls and don't support any in-call UI. 1269 * <p> 1270 * Note: the meaning of this flag is subtly different from the 1271 * PackageManager.FEATURE_TELEPHONY system feature, which is available 1272 * on any device with a telephony radio, even if the device is 1273 * data-only. 1274 * 1275 * @hide pending API review 1276 */ 1277 public boolean isVoiceCapable() { 1278 if (sContext == null) return true; 1279 return sContext.getResources().getBoolean( 1280 com.android.internal.R.bool.config_voice_capable); 1281 } 1282 1283 /** 1284 * @return true if the current device supports sms service. 1285 * <p> 1286 * If true, this means that the device supports both sending and 1287 * receiving sms via the telephony network. 1288 * <p> 1289 * Note: Voicemail waiting sms, cell broadcasting sms, and MMS are 1290 * disabled when device doesn't support sms. 1291 * 1292 * @hide pending API review 1293 */ 1294 public boolean isSmsCapable() { 1295 if (sContext == null) return true; 1296 return sContext.getResources().getBoolean( 1297 com.android.internal.R.bool.config_sms_capable); 1298 } 1299 1300 /** 1301 * Returns all observed cell information of the device. 1302 * 1303 * @return List of CellInfo or null if info unavailable. 1304 * 1305 * <p>Requires Permission: 1306 * (@link android.Manifest.permission#ACCESS_COARSE_UPDATES} 1307 */ 1308 public List<CellInfo> getAllCellInfo() { 1309 try { 1310 return getITelephony().getAllCellInfo(); 1311 } catch (RemoteException ex) { 1312 return null; 1313 } catch (NullPointerException ex) { 1314 return null; 1315 } 1316 } 1317} 1318