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 17 package android.telephony; 18 19 import static com.android.internal.util.Preconditions.checkNotNull; 20 21 import android.annotation.IntDef; 22 import android.annotation.Nullable; 23 import android.annotation.RequiresPermission; 24 import android.annotation.SdkConstant; 25 import android.annotation.SuppressLint; 26 import android.annotation.SdkConstant.SdkConstantType; 27 import android.annotation.SystemApi; 28 import android.annotation.SystemService; 29 import android.annotation.WorkerThread; 30 import android.app.ActivityThread; 31 import android.app.PendingIntent; 32 import android.content.ContentResolver; 33 import android.content.Context; 34 import android.content.Intent; 35 import android.net.ConnectivityManager; 36 import android.net.NetworkStats; 37 import android.net.Uri; 38 import android.os.BatteryStats; 39 import android.os.Bundle; 40 import android.os.Handler; 41 import android.os.PersistableBundle; 42 import android.os.RemoteException; 43 import android.os.ResultReceiver; 44 import android.os.ServiceManager; 45 import android.os.SystemProperties; 46 import android.provider.Settings; 47 import android.provider.Settings.SettingNotFoundException; 48 import android.service.carrier.CarrierIdentifier; 49 import android.telecom.PhoneAccount; 50 import android.telecom.PhoneAccountHandle; 51 import android.telephony.VisualVoicemailService.VisualVoicemailTask; 52 import android.telephony.ims.feature.ImsFeature; 53 import android.util.Log; 54 55 import com.android.ims.internal.IImsServiceController; 56 import com.android.ims.internal.IImsServiceFeatureListener; 57 import com.android.internal.annotations.VisibleForTesting; 58 import com.android.internal.telecom.ITelecomService; 59 import com.android.internal.telephony.CellNetworkScanResult; 60 import com.android.internal.telephony.IPhoneSubInfo; 61 import com.android.internal.telephony.ITelephony; 62 import com.android.internal.telephony.ITelephonyRegistry; 63 import com.android.internal.telephony.OperatorInfo; 64 import com.android.internal.telephony.PhoneConstants; 65 import com.android.internal.telephony.RILConstants; 66 import com.android.internal.telephony.TelephonyProperties; 67 68 import java.io.FileInputStream; 69 import java.io.IOException; 70 import java.lang.annotation.Retention; 71 import java.lang.annotation.RetentionPolicy; 72 import java.util.ArrayList; 73 import java.util.Collections; 74 import java.util.List; 75 import java.util.regex.Matcher; 76 import java.util.regex.Pattern; 77 78 /** 79 * Provides access to information about the telephony services on 80 * the device. Applications can use the methods in this class to 81 * determine telephony services and states, as well as to access some 82 * types of subscriber information. Applications can also register 83 * a listener to receive notification of telephony state changes. 84 * <p> 85 * The returned TelephonyManager will use the default subscription for all calls. 86 * To call an API for a specific subscription, use {@link #createForSubscriptionId(int)}. e.g. 87 * <code> 88 * telephonyManager = defaultSubTelephonyManager.createForSubscriptionId(subId); 89 * </code> 90 * <p> 91 * Note that access to some telephony information is 92 * permission-protected. Your application cannot access the protected 93 * information unless it has the appropriate permissions declared in 94 * its manifest file. Where permissions apply, they are noted in the 95 * the methods through which you access the protected information. 96 */ 97 @SystemService(Context.TELEPHONY_SERVICE) 98 public class TelephonyManager { 99 private static final String TAG = "TelephonyManager"; 100 101 /** 102 * The key to use when placing the result of {@link #requestModemActivityInfo(ResultReceiver)} 103 * into the ResultReceiver Bundle. 104 * @hide 105 */ 106 public static final String MODEM_ACTIVITY_RESULT_KEY = 107 BatteryStats.RESULT_RECEIVER_CONTROLLER_KEY; 108 109 /** 110 * The allowed states of Wi-Fi calling. 111 * 112 * @hide 113 */ 114 public interface WifiCallingChoices { 115 /** Always use Wi-Fi calling */ 116 static final int ALWAYS_USE = 0; 117 /** Ask the user whether to use Wi-Fi on every call */ 118 static final int ASK_EVERY_TIME = 1; 119 /** Never use Wi-Fi calling */ 120 static final int NEVER_USE = 2; 121 } 122 123 /** The otaspMode passed to PhoneStateListener#onOtaspChanged */ 124 /** @hide */ 125 static public final int OTASP_UNINITIALIZED = 0; 126 /** @hide */ 127 static public final int OTASP_UNKNOWN = 1; 128 /** @hide */ 129 static public final int OTASP_NEEDED = 2; 130 /** @hide */ 131 static public final int OTASP_NOT_NEEDED = 3; 132 /* OtaUtil has conflict enum 4: OtaUtils.OTASP_FAILURE_SPC_RETRIES */ 133 /** @hide */ 134 static public final int OTASP_SIM_UNPROVISIONED = 5; 135 136 137 /** @hide */ 138 static public final int KEY_TYPE_EPDG = 1; 139 140 /** @hide */ 141 static public final int KEY_TYPE_WLAN = 2; 142 143 private final Context mContext; 144 private final int mSubId; 145 private SubscriptionManager mSubscriptionManager; 146 private TelephonyScanManager mTelephonyScanManager; 147 148 private static String multiSimConfig = 149 SystemProperties.get(TelephonyProperties.PROPERTY_MULTI_SIM_CONFIG); 150 151 /** Enum indicating multisim variants 152 * DSDS - Dual SIM Dual Standby 153 * DSDA - Dual SIM Dual Active 154 * TSTS - Triple SIM Triple Standby 155 **/ 156 /** @hide */ 157 public enum MultiSimVariants { 158 DSDS, 159 DSDA, 160 TSTS, 161 UNKNOWN 162 }; 163 164 /** @hide */ TelephonyManager(Context context)165 public TelephonyManager(Context context) { 166 this(context, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 167 } 168 169 /** @hide */ TelephonyManager(Context context, int subId)170 public TelephonyManager(Context context, int subId) { 171 mSubId = subId; 172 Context appContext = context.getApplicationContext(); 173 if (appContext != null) { 174 mContext = appContext; 175 } else { 176 mContext = context; 177 } 178 mSubscriptionManager = SubscriptionManager.from(mContext); 179 } 180 181 /** @hide */ TelephonyManager()182 private TelephonyManager() { 183 mContext = null; 184 mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; 185 } 186 187 private static TelephonyManager sInstance = new TelephonyManager(); 188 189 /** @hide 190 /* @deprecated - use getSystemService as described above */ getDefault()191 public static TelephonyManager getDefault() { 192 return sInstance; 193 } 194 getOpPackageName()195 private String getOpPackageName() { 196 // For legacy reasons the TelephonyManager has API for getting 197 // a static instance with no context set preventing us from 198 // getting the op package name. As a workaround we do a best 199 // effort and get the context from the current activity thread. 200 if (mContext != null) { 201 return mContext.getOpPackageName(); 202 } 203 return ActivityThread.currentOpPackageName(); 204 } 205 206 /** 207 * Returns the multi SIM variant 208 * Returns DSDS for Dual SIM Dual Standby 209 * Returns DSDA for Dual SIM Dual Active 210 * Returns TSTS for Triple SIM Triple Standby 211 * Returns UNKNOWN for others 212 */ 213 /** {@hide} */ getMultiSimConfiguration()214 public MultiSimVariants getMultiSimConfiguration() { 215 String mSimConfig = 216 SystemProperties.get(TelephonyProperties.PROPERTY_MULTI_SIM_CONFIG); 217 if (mSimConfig.equals("dsds")) { 218 return MultiSimVariants.DSDS; 219 } else if (mSimConfig.equals("dsda")) { 220 return MultiSimVariants.DSDA; 221 } else if (mSimConfig.equals("tsts")) { 222 return MultiSimVariants.TSTS; 223 } else { 224 return MultiSimVariants.UNKNOWN; 225 } 226 } 227 228 229 /** 230 * Returns the number of phones available. 231 * Returns 0 if none of voice, sms, data is not supported 232 * Returns 1 for Single standby mode (Single SIM functionality) 233 * Returns 2 for Dual standby mode.(Dual SIM functionality) 234 */ getPhoneCount()235 public int getPhoneCount() { 236 int phoneCount = 1; 237 switch (getMultiSimConfiguration()) { 238 case UNKNOWN: 239 // if voice or sms or data is supported, return 1 otherwise 0 240 if (isVoiceCapable() || isSmsCapable()) { 241 phoneCount = 1; 242 } else { 243 // todo: try to clean this up further by getting rid of the nested conditions 244 if (mContext == null) { 245 phoneCount = 1; 246 } else { 247 // check for data support 248 ConnectivityManager cm = (ConnectivityManager)mContext.getSystemService( 249 Context.CONNECTIVITY_SERVICE); 250 if (cm == null) { 251 phoneCount = 1; 252 } else { 253 if (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE)) { 254 phoneCount = 1; 255 } else { 256 phoneCount = 0; 257 } 258 } 259 } 260 } 261 break; 262 case DSDS: 263 case DSDA: 264 phoneCount = PhoneConstants.MAX_PHONE_COUNT_DUAL_SIM; 265 break; 266 case TSTS: 267 phoneCount = PhoneConstants.MAX_PHONE_COUNT_TRI_SIM; 268 break; 269 } 270 return phoneCount; 271 } 272 273 /** {@hide} */ from(Context context)274 public static TelephonyManager from(Context context) { 275 return (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 276 } 277 278 /** 279 * Create a new TelephonyManager object pinned to the given subscription ID. 280 * 281 * @return a TelephonyManager that uses the given subId for all calls. 282 */ createForSubscriptionId(int subId)283 public TelephonyManager createForSubscriptionId(int subId) { 284 // Don't reuse any TelephonyManager objects. 285 return new TelephonyManager(mContext, subId); 286 } 287 288 /** 289 * Create a new TelephonyManager object pinned to the subscription ID associated with the given 290 * phone account. 291 * 292 * @return a TelephonyManager that uses the given phone account for all calls, or {@code null} 293 * if the phone account does not correspond to a valid subscription ID. 294 */ 295 @Nullable createForPhoneAccountHandle(PhoneAccountHandle phoneAccountHandle)296 public TelephonyManager createForPhoneAccountHandle(PhoneAccountHandle phoneAccountHandle) { 297 int subId = getSubIdForPhoneAccountHandle(phoneAccountHandle); 298 if (!SubscriptionManager.isValidSubscriptionId(subId)) { 299 return null; 300 } 301 return new TelephonyManager(mContext, subId); 302 } 303 304 /** {@hide} */ isMultiSimEnabled()305 public boolean isMultiSimEnabled() { 306 return (multiSimConfig.equals("dsds") || multiSimConfig.equals("dsda") || 307 multiSimConfig.equals("tsts")); 308 } 309 310 // 311 // Broadcast Intent actions 312 // 313 314 /** 315 * Broadcast intent action indicating that the call state 316 * on the device has changed. 317 * 318 * <p> 319 * The {@link #EXTRA_STATE} extra indicates the new call state. 320 * If the new state is RINGING, a second extra 321 * {@link #EXTRA_INCOMING_NUMBER} provides the incoming phone number as 322 * a String. 323 * 324 * <p class="note"> 325 * This was a {@link android.content.Context#sendStickyBroadcast sticky} 326 * broadcast in version 1.0, but it is no longer sticky. 327 * Instead, use {@link #getCallState} to synchronously query the current call state. 328 * 329 * @see #EXTRA_STATE 330 * @see #EXTRA_INCOMING_NUMBER 331 * @see #getCallState 332 */ 333 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 334 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 335 public static final String ACTION_PHONE_STATE_CHANGED = 336 "android.intent.action.PHONE_STATE"; 337 338 /** 339 * The Phone app sends this intent when a user opts to respond-via-message during an incoming 340 * call. By default, the device's default SMS app consumes this message and sends a text message 341 * to the caller. A third party app can also provide this functionality by consuming this Intent 342 * with a {@link android.app.Service} and sending the message using its own messaging system. 343 * <p>The intent contains a URI (available from {@link android.content.Intent#getData}) 344 * describing the recipient, using either the {@code sms:}, {@code smsto:}, {@code mms:}, 345 * or {@code mmsto:} URI schema. Each of these URI schema carry the recipient information the 346 * same way: the path part of the URI contains the recipient's phone number or a comma-separated 347 * set of phone numbers if there are multiple recipients. For example, {@code 348 * smsto:2065551234}.</p> 349 * 350 * <p>The intent may also contain extras for the message text (in {@link 351 * android.content.Intent#EXTRA_TEXT}) and a message subject 352 * (in {@link android.content.Intent#EXTRA_SUBJECT}).</p> 353 * 354 * <p class="note"><strong>Note:</strong> 355 * The intent-filter that consumes this Intent needs to be in a {@link android.app.Service} 356 * that requires the 357 * permission {@link android.Manifest.permission#SEND_RESPOND_VIA_MESSAGE}.</p> 358 * <p>For example, the service that receives this intent can be declared in the manifest file 359 * with an intent filter like this:</p> 360 * <pre> 361 * <!-- Service that delivers SMS messages received from the phone "quick response" --> 362 * <service android:name=".HeadlessSmsSendService" 363 * android:permission="android.permission.SEND_RESPOND_VIA_MESSAGE" 364 * android:exported="true" > 365 * <intent-filter> 366 * <action android:name="android.intent.action.RESPOND_VIA_MESSAGE" /> 367 * <category android:name="android.intent.category.DEFAULT" /> 368 * <data android:scheme="sms" /> 369 * <data android:scheme="smsto" /> 370 * <data android:scheme="mms" /> 371 * <data android:scheme="mmsto" /> 372 * </intent-filter> 373 * </service></pre> 374 * <p> 375 * Output: nothing. 376 */ 377 @SdkConstant(SdkConstantType.SERVICE_ACTION) 378 public static final String ACTION_RESPOND_VIA_MESSAGE = 379 "android.intent.action.RESPOND_VIA_MESSAGE"; 380 381 /** 382 * The emergency dialer may choose to present activities with intent filters for this 383 * action as emergency assistance buttons that launch the activity when clicked. 384 * 385 * @hide 386 */ 387 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 388 public static final String ACTION_EMERGENCY_ASSISTANCE = 389 "android.telephony.action.EMERGENCY_ASSISTANCE"; 390 391 /** 392 * A boolean meta-data value indicating whether the voicemail settings should be hidden in the 393 * call settings page launched by 394 * {@link android.telecom.TelecomManager#ACTION_SHOW_CALL_SETTINGS}. 395 * Dialer implementations (see {@link android.telecom.TelecomManager#getDefaultDialerPackage()}) 396 * which would also like to manage voicemail settings should set this meta-data to {@code true} 397 * in the manifest registration of their application. 398 * 399 * @see android.telecom.TelecomManager#ACTION_SHOW_CALL_SETTINGS 400 * @see #ACTION_CONFIGURE_VOICEMAIL 401 * @see #EXTRA_HIDE_PUBLIC_SETTINGS 402 */ 403 public static final String METADATA_HIDE_VOICEMAIL_SETTINGS_MENU = 404 "android.telephony.HIDE_VOICEMAIL_SETTINGS_MENU"; 405 406 /** 407 * Open the voicemail settings activity to make changes to voicemail configuration. 408 * 409 * <p> 410 * The {@link #EXTRA_HIDE_PUBLIC_SETTINGS} hides settings the dialer will modify through public 411 * API if set. 412 * 413 * @see #EXTRA_HIDE_PUBLIC_SETTINGS 414 */ 415 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 416 public static final String ACTION_CONFIGURE_VOICEMAIL = 417 "android.telephony.action.CONFIGURE_VOICEMAIL"; 418 419 /** 420 * The boolean value indicating whether the voicemail settings activity launched by {@link 421 * #ACTION_CONFIGURE_VOICEMAIL} should hide settings accessible through public API. This is 422 * used by dialer implementations which provides their own voicemail settings UI, but still 423 * needs to expose device specific voicemail settings to the user. 424 * 425 * @see #ACTION_CONFIGURE_VOICEMAIL 426 * @see #METADATA_HIDE_VOICEMAIL_SETTINGS_MENU 427 */ 428 public static final String EXTRA_HIDE_PUBLIC_SETTINGS = 429 "android.telephony.extra.HIDE_PUBLIC_SETTINGS"; 430 431 /** 432 * @hide 433 */ 434 public static final boolean EMERGENCY_ASSISTANCE_ENABLED = true; 435 436 /** 437 * The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast 438 * for a String containing the new call state. 439 * 440 * <p class="note"> 441 * Retrieve with 442 * {@link android.content.Intent#getStringExtra(String)}. 443 * 444 * @see #EXTRA_STATE_IDLE 445 * @see #EXTRA_STATE_RINGING 446 * @see #EXTRA_STATE_OFFHOOK 447 */ 448 public static final String EXTRA_STATE = PhoneConstants.STATE_KEY; 449 450 /** 451 * Value used with {@link #EXTRA_STATE} corresponding to 452 * {@link #CALL_STATE_IDLE}. 453 */ 454 public static final String EXTRA_STATE_IDLE = PhoneConstants.State.IDLE.toString(); 455 456 /** 457 * Value used with {@link #EXTRA_STATE} corresponding to 458 * {@link #CALL_STATE_RINGING}. 459 */ 460 public static final String EXTRA_STATE_RINGING = PhoneConstants.State.RINGING.toString(); 461 462 /** 463 * Value used with {@link #EXTRA_STATE} corresponding to 464 * {@link #CALL_STATE_OFFHOOK}. 465 */ 466 public static final String EXTRA_STATE_OFFHOOK = PhoneConstants.State.OFFHOOK.toString(); 467 468 /** 469 * The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast 470 * for a String containing the incoming phone number. 471 * Only valid when the new call state is RINGING. 472 * 473 * <p class="note"> 474 * Retrieve with 475 * {@link android.content.Intent#getStringExtra(String)}. 476 */ 477 public static final String EXTRA_INCOMING_NUMBER = "incoming_number"; 478 479 /** 480 * Broadcast intent action indicating that a precise call state 481 * (cellular) on the device has changed. 482 * 483 * <p> 484 * The {@link #EXTRA_RINGING_CALL_STATE} extra indicates the ringing call state. 485 * The {@link #EXTRA_FOREGROUND_CALL_STATE} extra indicates the foreground call state. 486 * The {@link #EXTRA_BACKGROUND_CALL_STATE} extra indicates the background call state. 487 * The {@link #EXTRA_DISCONNECT_CAUSE} extra indicates the disconnect cause. 488 * The {@link #EXTRA_PRECISE_DISCONNECT_CAUSE} extra indicates the precise disconnect cause. 489 * 490 * <p class="note"> 491 * Requires the READ_PRECISE_PHONE_STATE permission. 492 * 493 * @see #EXTRA_RINGING_CALL_STATE 494 * @see #EXTRA_FOREGROUND_CALL_STATE 495 * @see #EXTRA_BACKGROUND_CALL_STATE 496 * @see #EXTRA_DISCONNECT_CAUSE 497 * @see #EXTRA_PRECISE_DISCONNECT_CAUSE 498 * 499 * <p class="note"> 500 * Requires the READ_PRECISE_PHONE_STATE permission. 501 * 502 * @hide 503 */ 504 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 505 public static final String ACTION_PRECISE_CALL_STATE_CHANGED = 506 "android.intent.action.PRECISE_CALL_STATE"; 507 508 /** 509 * The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast 510 * for an integer containing the state of the current ringing call. 511 * 512 * @see PreciseCallState#PRECISE_CALL_STATE_NOT_VALID 513 * @see PreciseCallState#PRECISE_CALL_STATE_IDLE 514 * @see PreciseCallState#PRECISE_CALL_STATE_ACTIVE 515 * @see PreciseCallState#PRECISE_CALL_STATE_HOLDING 516 * @see PreciseCallState#PRECISE_CALL_STATE_DIALING 517 * @see PreciseCallState#PRECISE_CALL_STATE_ALERTING 518 * @see PreciseCallState#PRECISE_CALL_STATE_INCOMING 519 * @see PreciseCallState#PRECISE_CALL_STATE_WAITING 520 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTED 521 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTING 522 * 523 * <p class="note"> 524 * Retrieve with 525 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 526 * 527 * @hide 528 */ 529 public static final String EXTRA_RINGING_CALL_STATE = "ringing_state"; 530 531 /** 532 * The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast 533 * for an integer containing the state of the current foreground call. 534 * 535 * @see PreciseCallState#PRECISE_CALL_STATE_NOT_VALID 536 * @see PreciseCallState#PRECISE_CALL_STATE_IDLE 537 * @see PreciseCallState#PRECISE_CALL_STATE_ACTIVE 538 * @see PreciseCallState#PRECISE_CALL_STATE_HOLDING 539 * @see PreciseCallState#PRECISE_CALL_STATE_DIALING 540 * @see PreciseCallState#PRECISE_CALL_STATE_ALERTING 541 * @see PreciseCallState#PRECISE_CALL_STATE_INCOMING 542 * @see PreciseCallState#PRECISE_CALL_STATE_WAITING 543 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTED 544 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTING 545 * 546 * <p class="note"> 547 * Retrieve with 548 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 549 * 550 * @hide 551 */ 552 public static final String EXTRA_FOREGROUND_CALL_STATE = "foreground_state"; 553 554 /** 555 * The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast 556 * for an integer containing the state of the current background call. 557 * 558 * @see PreciseCallState#PRECISE_CALL_STATE_NOT_VALID 559 * @see PreciseCallState#PRECISE_CALL_STATE_IDLE 560 * @see PreciseCallState#PRECISE_CALL_STATE_ACTIVE 561 * @see PreciseCallState#PRECISE_CALL_STATE_HOLDING 562 * @see PreciseCallState#PRECISE_CALL_STATE_DIALING 563 * @see PreciseCallState#PRECISE_CALL_STATE_ALERTING 564 * @see PreciseCallState#PRECISE_CALL_STATE_INCOMING 565 * @see PreciseCallState#PRECISE_CALL_STATE_WAITING 566 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTED 567 * @see PreciseCallState#PRECISE_CALL_STATE_DISCONNECTING 568 * 569 * <p class="note"> 570 * Retrieve with 571 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 572 * 573 * @hide 574 */ 575 public static final String EXTRA_BACKGROUND_CALL_STATE = "background_state"; 576 577 /** 578 * The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast 579 * for an integer containing the disconnect cause. 580 * 581 * @see DisconnectCause 582 * 583 * <p class="note"> 584 * Retrieve with 585 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 586 * 587 * @hide 588 */ 589 public static final String EXTRA_DISCONNECT_CAUSE = "disconnect_cause"; 590 591 /** 592 * The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast 593 * for an integer containing the disconnect cause provided by the RIL. 594 * 595 * @see PreciseDisconnectCause 596 * 597 * <p class="note"> 598 * Retrieve with 599 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 600 * 601 * @hide 602 */ 603 public static final String EXTRA_PRECISE_DISCONNECT_CAUSE = "precise_disconnect_cause"; 604 605 /** 606 * Broadcast intent action indicating a data connection has changed, 607 * providing precise information about the connection. 608 * 609 * <p> 610 * The {@link #EXTRA_DATA_STATE} extra indicates the connection state. 611 * The {@link #EXTRA_DATA_NETWORK_TYPE} extra indicates the connection network type. 612 * The {@link #EXTRA_DATA_APN_TYPE} extra indicates the APN type. 613 * The {@link #EXTRA_DATA_APN} extra indicates the APN. 614 * The {@link #EXTRA_DATA_CHANGE_REASON} extra indicates the connection change reason. 615 * The {@link #EXTRA_DATA_IFACE_PROPERTIES} extra indicates the connection interface. 616 * The {@link #EXTRA_DATA_FAILURE_CAUSE} extra indicates the connection fail cause. 617 * 618 * <p class="note"> 619 * Requires the READ_PRECISE_PHONE_STATE permission. 620 * 621 * @see #EXTRA_DATA_STATE 622 * @see #EXTRA_DATA_NETWORK_TYPE 623 * @see #EXTRA_DATA_APN_TYPE 624 * @see #EXTRA_DATA_APN 625 * @see #EXTRA_DATA_CHANGE_REASON 626 * @see #EXTRA_DATA_IFACE 627 * @see #EXTRA_DATA_FAILURE_CAUSE 628 * @hide 629 * 630 * @deprecated If the app is running in the background, it won't be able to receive this 631 * broadcast. Apps should use ConnectivityManager {@link #registerNetworkCallback( 632 * android.net.NetworkRequest, ConnectivityManager.NetworkCallback)} to listen for network 633 * changes. 634 */ 635 @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) 636 @Deprecated 637 public static final String ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED = 638 "android.intent.action.PRECISE_DATA_CONNECTION_STATE_CHANGED"; 639 640 /** 641 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 642 * for an integer containing the state of the current data connection. 643 * 644 * @see TelephonyManager#DATA_UNKNOWN 645 * @see TelephonyManager#DATA_DISCONNECTED 646 * @see TelephonyManager#DATA_CONNECTING 647 * @see TelephonyManager#DATA_CONNECTED 648 * @see TelephonyManager#DATA_SUSPENDED 649 * 650 * <p class="note"> 651 * Retrieve with 652 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 653 * 654 * @hide 655 */ 656 public static final String EXTRA_DATA_STATE = PhoneConstants.STATE_KEY; 657 658 /** 659 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 660 * for an integer containing the network type. 661 * 662 * @see TelephonyManager#NETWORK_TYPE_UNKNOWN 663 * @see TelephonyManager#NETWORK_TYPE_GPRS 664 * @see TelephonyManager#NETWORK_TYPE_EDGE 665 * @see TelephonyManager#NETWORK_TYPE_UMTS 666 * @see TelephonyManager#NETWORK_TYPE_CDMA 667 * @see TelephonyManager#NETWORK_TYPE_EVDO_0 668 * @see TelephonyManager#NETWORK_TYPE_EVDO_A 669 * @see TelephonyManager#NETWORK_TYPE_1xRTT 670 * @see TelephonyManager#NETWORK_TYPE_HSDPA 671 * @see TelephonyManager#NETWORK_TYPE_HSUPA 672 * @see TelephonyManager#NETWORK_TYPE_HSPA 673 * @see TelephonyManager#NETWORK_TYPE_IDEN 674 * @see TelephonyManager#NETWORK_TYPE_EVDO_B 675 * @see TelephonyManager#NETWORK_TYPE_LTE 676 * @see TelephonyManager#NETWORK_TYPE_EHRPD 677 * @see TelephonyManager#NETWORK_TYPE_HSPAP 678 * 679 * <p class="note"> 680 * Retrieve with 681 * {@link android.content.Intent#getIntExtra(String name, int defaultValue)}. 682 * 683 * @hide 684 */ 685 public static final String EXTRA_DATA_NETWORK_TYPE = PhoneConstants.DATA_NETWORK_TYPE_KEY; 686 687 /** 688 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 689 * for an String containing the data APN type. 690 * 691 * <p class="note"> 692 * Retrieve with 693 * {@link android.content.Intent#getStringExtra(String name)}. 694 * 695 * @hide 696 */ 697 public static final String EXTRA_DATA_APN_TYPE = PhoneConstants.DATA_APN_TYPE_KEY; 698 699 /** 700 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 701 * for an String containing the data APN. 702 * 703 * <p class="note"> 704 * Retrieve with 705 * {@link android.content.Intent#getStringExtra(String name)}. 706 * 707 * @hide 708 */ 709 public static final String EXTRA_DATA_APN = PhoneConstants.DATA_APN_KEY; 710 711 /** 712 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 713 * for an String representation of the change reason. 714 * 715 * <p class="note"> 716 * Retrieve with 717 * {@link android.content.Intent#getStringExtra(String name)}. 718 * 719 * @hide 720 */ 721 public static final String EXTRA_DATA_CHANGE_REASON = PhoneConstants.STATE_CHANGE_REASON_KEY; 722 723 /** 724 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 725 * for an String representation of the data interface. 726 * 727 * <p class="note"> 728 * Retrieve with 729 * {@link android.content.Intent#getParcelableExtra(String name)}. 730 * 731 * @hide 732 */ 733 public static final String EXTRA_DATA_LINK_PROPERTIES_KEY = PhoneConstants.DATA_LINK_PROPERTIES_KEY; 734 735 /** 736 * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast 737 * for the data connection fail cause. 738 * 739 * <p class="note"> 740 * Retrieve with 741 * {@link android.content.Intent#getStringExtra(String name)}. 742 * 743 * @hide 744 */ 745 public static final String EXTRA_DATA_FAILURE_CAUSE = PhoneConstants.DATA_FAILURE_CAUSE_KEY; 746 747 /** 748 * Broadcast intent action for letting the default dialer to know to show voicemail 749 * notification. 750 * 751 * <p> 752 * The {@link #EXTRA_PHONE_ACCOUNT_HANDLE} extra indicates which {@link PhoneAccountHandle} the 753 * voicemail is received on. 754 * The {@link #EXTRA_NOTIFICATION_COUNT} extra indicates the total numbers of unheard 755 * voicemails. 756 * The {@link #EXTRA_VOICEMAIL_NUMBER} extra indicates the voicemail number if available. 757 * The {@link #EXTRA_CALL_VOICEMAIL_INTENT} extra is a {@link android.app.PendingIntent} that 758 * will call the voicemail number when sent. This extra will be empty if the voicemail number 759 * is not set, and {@link #EXTRA_LAUNCH_VOICEMAIL_SETTINGS_INTENT} will be set instead. 760 * The {@link #EXTRA_LAUNCH_VOICEMAIL_SETTINGS_INTENT} extra is a 761 * {@link android.app.PendingIntent} that will launch the voicemail settings. This extra is only 762 * available when the voicemail number is not set. 763 * The {@link #EXTRA_IS_REFRESH} extra indicates whether the notification is a refresh or a new 764 * notification. 765 * 766 * @see #EXTRA_PHONE_ACCOUNT_HANDLE 767 * @see #EXTRA_NOTIFICATION_COUNT 768 * @see #EXTRA_VOICEMAIL_NUMBER 769 * @see #EXTRA_CALL_VOICEMAIL_INTENT 770 * @see #EXTRA_LAUNCH_VOICEMAIL_SETTINGS_INTENT 771 * @see #EXTRA_IS_REFRESH 772 */ 773 public static final String ACTION_SHOW_VOICEMAIL_NOTIFICATION = 774 "android.telephony.action.SHOW_VOICEMAIL_NOTIFICATION"; 775 776 /** 777 * The extra used with an {@link #ACTION_SHOW_VOICEMAIL_NOTIFICATION} {@code Intent} to specify 778 * the {@link PhoneAccountHandle} the notification is for. 779 * <p class="note"> 780 * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. 781 */ 782 public static final String EXTRA_PHONE_ACCOUNT_HANDLE = 783 "android.telephony.extra.PHONE_ACCOUNT_HANDLE"; 784 785 /** 786 * The number of voice messages associated with the notification. 787 */ 788 public static final String EXTRA_NOTIFICATION_COUNT = 789 "android.telephony.extra.NOTIFICATION_COUNT"; 790 791 /** 792 * The voicemail number. 793 */ 794 public static final String EXTRA_VOICEMAIL_NUMBER = 795 "android.telephony.extra.VOICEMAIL_NUMBER"; 796 797 /** 798 * The intent to call voicemail. 799 */ 800 public static final String EXTRA_CALL_VOICEMAIL_INTENT = 801 "android.telephony.extra.CALL_VOICEMAIL_INTENT"; 802 803 /** 804 * The intent to launch voicemail settings. 805 */ 806 public static final String EXTRA_LAUNCH_VOICEMAIL_SETTINGS_INTENT = 807 "android.telephony.extra.LAUNCH_VOICEMAIL_SETTINGS_INTENT"; 808 809 /** 810 * Boolean value representing whether the {@link 811 * TelephonyManager#ACTION_SHOW_VOICEMAIL_NOTIFICATION} is new or a refresh of an existing 812 * notification. Notification refresh happens after reboot or connectivity changes. The user has 813 * already been notified for the voicemail so it should not alert the user, and should not be 814 * shown again if the user has dismissed it. 815 */ 816 public static final String EXTRA_IS_REFRESH = "android.telephony.extra.IS_REFRESH"; 817 818 /** 819 * {@link android.telecom.Connection} event used to indicate that an IMS call has be 820 * successfully handed over from WIFI to LTE. 821 * <p> 822 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 823 * The {@link Bundle} parameter is expected to be null when this connection event is used. 824 * @hide 825 */ 826 public static final String EVENT_HANDOVER_VIDEO_FROM_WIFI_TO_LTE = 827 "android.telephony.event.EVENT_HANDOVER_VIDEO_FROM_WIFI_TO_LTE"; 828 829 /** 830 * {@link android.telecom.Connection} event used to indicate that an IMS call failed to be 831 * handed over from LTE to WIFI. 832 * <p> 833 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 834 * The {@link Bundle} parameter is expected to be null when this connection event is used. 835 * @hide 836 */ 837 public static final String EVENT_HANDOVER_TO_WIFI_FAILED = 838 "android.telephony.event.EVENT_HANDOVER_TO_WIFI_FAILED"; 839 840 /** 841 * {@link android.telecom.Connection} event used to indicate that a video call was downgraded to 842 * audio because the data limit was reached. 843 * <p> 844 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 845 * The {@link Bundle} parameter is expected to be null when this connection event is used. 846 * @hide 847 */ 848 public static final String EVENT_DOWNGRADE_DATA_LIMIT_REACHED = 849 "android.telephony.event.EVENT_DOWNGRADE_DATA_LIMIT_REACHED"; 850 851 /** 852 * {@link android.telecom.Connection} event used to indicate that a video call was downgraded to 853 * audio because the data was disabled. 854 * <p> 855 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 856 * The {@link Bundle} parameter is expected to be null when this connection event is used. 857 * @hide 858 */ 859 public static final String EVENT_DOWNGRADE_DATA_DISABLED = 860 "android.telephony.event.EVENT_DOWNGRADE_DATA_DISABLED"; 861 862 /** 863 * {@link android.telecom.Connection} event used to indicate that the InCall UI should notify 864 * the user when an international call is placed while on WFC only. 865 * <p> 866 * Used when the carrier config value 867 * {@link CarrierConfigManager#KEY_NOTIFY_INTERNATIONAL_CALL_ON_WFC_BOOL} is true, the device 868 * is on WFC (VoLTE not available) and an international number is dialed. 869 * <p> 870 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 871 * The {@link Bundle} parameter is expected to be null when this connection event is used. 872 * @hide 873 */ 874 public static final String EVENT_NOTIFY_INTERNATIONAL_CALL_ON_WFC = 875 "android.telephony.event.EVENT_NOTIFY_INTERNATIONAL_CALL_ON_WFC"; 876 877 /** 878 * {@link android.telecom.Connection} event used to indicate that an outgoing call has been 879 * forwarded to another number. 880 * <p> 881 * Sent in response to an IMS supplementary service notification indicating the call has been 882 * forwarded. 883 * <p> 884 * Sent via {@link android.telecom.Connection#sendConnectionEvent(String, Bundle)}. 885 * The {@link Bundle} parameter is expected to be null when this connection event is used. 886 * @hide 887 */ 888 public static final String EVENT_CALL_FORWARDED = 889 "android.telephony.event.EVENT_CALL_FORWARDED"; 890 891 /* Visual voicemail protocols */ 892 893 /** 894 * The OMTP protocol. 895 */ 896 public static final String VVM_TYPE_OMTP = "vvm_type_omtp"; 897 898 /** 899 * A flavor of OMTP protocol with a different mobile originated (MO) format 900 */ 901 public static final String VVM_TYPE_CVVM = "vvm_type_cvvm"; 902 903 /** 904 * Key in bundle returned by {@link #getVisualVoicemailPackageName()}, indicating whether visual 905 * voicemail was enabled or disabled by the user. If the user never explicitly changed this 906 * setting, this key will not exist. 907 * 908 * @see #getVisualVoicemailSettings() 909 * @hide 910 */ 911 @SystemApi 912 public static final String EXTRA_VISUAL_VOICEMAIL_ENABLED_BY_USER_BOOL = 913 "android.telephony.extra.VISUAL_VOICEMAIL_ENABLED_BY_USER_BOOL"; 914 915 /** 916 * Key in bundle returned by {@link #getVisualVoicemailPackageName()}, indicating the voicemail 917 * access PIN scrambled during the auto provisioning process. The user is expected to reset 918 * their PIN if this value is not {@code null}. 919 * 920 * @see #getVisualVoicemailSettings() 921 * @hide 922 */ 923 @SystemApi 924 public static final String EXTRA_VOICEMAIL_SCRAMBLED_PIN_STRING = 925 "android.telephony.extra.VOICEMAIL_SCRAMBLED_PIN_STRING"; 926 927 /** 928 * @hide 929 */ 930 public static final String USSD_RESPONSE = "USSD_RESPONSE"; 931 932 /** 933 * USSD return code success. 934 * @hide 935 */ 936 public static final int USSD_RETURN_SUCCESS = 100; 937 938 /** 939 * Failed code returned when the mobile network has failed to complete a USSD request. 940 * <p> 941 * Returned via {@link TelephonyManager.UssdResponseCallback#onReceiveUssdResponseFailed( 942 * TelephonyManager, String, int)}. 943 */ 944 public static final int USSD_RETURN_FAILURE = -1; 945 946 /** 947 * Failure code returned when a USSD request has failed to execute because the Telephony 948 * service is unavailable. 949 * <p> 950 * Returned via {@link TelephonyManager.UssdResponseCallback#onReceiveUssdResponseFailed( 951 * TelephonyManager, String, int)}. 952 */ 953 public static final int USSD_ERROR_SERVICE_UNAVAIL = -2; 954 955 // 956 // 957 // Device Info 958 // 959 // 960 961 /** 962 * Returns the software version number for the device, for example, 963 * the IMEI/SV for GSM phones. Return null if the software version is 964 * not available. 965 */ 966 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDeviceSoftwareVersion()967 public String getDeviceSoftwareVersion() { 968 return getDeviceSoftwareVersion(getSlotIndex()); 969 } 970 971 /** 972 * Returns the software version number for the device, for example, 973 * the IMEI/SV for GSM phones. Return null if the software version is 974 * not available. 975 * 976 * @param slotIndex of which deviceID is returned 977 */ 978 /** {@hide} */ 979 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDeviceSoftwareVersion(int slotIndex)980 public String getDeviceSoftwareVersion(int slotIndex) { 981 ITelephony telephony = getITelephony(); 982 if (telephony == null) return null; 983 984 try { 985 return telephony.getDeviceSoftwareVersionForSlot(slotIndex, getOpPackageName()); 986 } catch (RemoteException ex) { 987 return null; 988 } catch (NullPointerException ex) { 989 return null; 990 } 991 } 992 993 /** 994 * Returns the unique device ID, for example, the IMEI for GSM and the MEID 995 * or ESN for CDMA phones. Return null if device ID is not available. 996 * 997 * @deprecated Use (@link getImei} which returns IMEI for GSM or (@link getMeid} which returns 998 * MEID for CDMA. 999 */ 1000 @Deprecated 1001 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDeviceId()1002 public String getDeviceId() { 1003 try { 1004 ITelephony telephony = getITelephony(); 1005 if (telephony == null) 1006 return null; 1007 return telephony.getDeviceId(mContext.getOpPackageName()); 1008 } catch (RemoteException ex) { 1009 return null; 1010 } catch (NullPointerException ex) { 1011 return null; 1012 } 1013 } 1014 1015 /** 1016 * Returns the unique device ID of a subscription, for example, the IMEI for 1017 * GSM and the MEID for CDMA phones. Return null if device ID is not available. 1018 * 1019 * @param slotIndex of which deviceID is returned 1020 * 1021 * @deprecated Use (@link getImei} which returns IMEI for GSM or (@link getMeid} which returns 1022 * MEID for CDMA. 1023 */ 1024 @Deprecated 1025 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDeviceId(int slotIndex)1026 public String getDeviceId(int slotIndex) { 1027 // FIXME this assumes phoneId == slotIndex 1028 try { 1029 IPhoneSubInfo info = getSubscriberInfo(); 1030 if (info == null) 1031 return null; 1032 return info.getDeviceIdForPhone(slotIndex, mContext.getOpPackageName()); 1033 } catch (RemoteException ex) { 1034 return null; 1035 } catch (NullPointerException ex) { 1036 return null; 1037 } 1038 } 1039 1040 /** 1041 * Returns the IMEI (International Mobile Equipment Identity). Return null if IMEI is not 1042 * available. 1043 */ 1044 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getImei()1045 public String getImei() { 1046 return getImei(getSlotIndex()); 1047 } 1048 1049 /** 1050 * Returns the IMEI (International Mobile Equipment Identity). Return null if IMEI is not 1051 * available. 1052 * 1053 * @param slotIndex of which IMEI is returned 1054 */ 1055 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getImei(int slotIndex)1056 public String getImei(int slotIndex) { 1057 ITelephony telephony = getITelephony(); 1058 if (telephony == null) return null; 1059 1060 try { 1061 return telephony.getImeiForSlot(slotIndex, getOpPackageName()); 1062 } catch (RemoteException ex) { 1063 return null; 1064 } catch (NullPointerException ex) { 1065 return null; 1066 } 1067 } 1068 1069 /** 1070 * Returns the MEID (Mobile Equipment Identifier). Return null if MEID is not available. 1071 */ 1072 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getMeid()1073 public String getMeid() { 1074 return getMeid(getSlotIndex()); 1075 } 1076 1077 /** 1078 * Returns the MEID (Mobile Equipment Identifier). Return null if MEID is not available. 1079 * 1080 * @param slotIndex of which MEID is returned 1081 */ 1082 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getMeid(int slotIndex)1083 public String getMeid(int slotIndex) { 1084 ITelephony telephony = getITelephony(); 1085 if (telephony == null) return null; 1086 1087 try { 1088 return telephony.getMeidForSlot(slotIndex, getOpPackageName()); 1089 } catch (RemoteException ex) { 1090 return null; 1091 } catch (NullPointerException ex) { 1092 return null; 1093 } 1094 } 1095 1096 /** 1097 * Returns the NAI. Return null if NAI is not available. 1098 * 1099 */ 1100 /** {@hide}*/ getNai()1101 public String getNai() { 1102 return getNai(getSlotIndex()); 1103 } 1104 1105 /** 1106 * Returns the NAI. Return null if NAI is not available. 1107 * 1108 * @param slotIndex of which Nai is returned 1109 */ 1110 /** {@hide}*/ getNai(int slotIndex)1111 public String getNai(int slotIndex) { 1112 int[] subId = SubscriptionManager.getSubId(slotIndex); 1113 try { 1114 IPhoneSubInfo info = getSubscriberInfo(); 1115 if (info == null) 1116 return null; 1117 String nai = info.getNaiForSubscriber(subId[0], mContext.getOpPackageName()); 1118 if (Log.isLoggable(TAG, Log.VERBOSE)) { 1119 Rlog.v(TAG, "Nai = " + nai); 1120 } 1121 return nai; 1122 } catch (RemoteException ex) { 1123 return null; 1124 } catch (NullPointerException ex) { 1125 return null; 1126 } 1127 } 1128 1129 /** 1130 * Returns the current location of the device. 1131 *<p> 1132 * If there is only one radio in the device and that radio has an LTE connection, 1133 * this method will return null. The implementation must not to try add LTE 1134 * identifiers into the existing cdma/gsm classes. 1135 *<p> 1136 * @return Current location of the device or null if not available. 1137 * 1138 * @deprecated use {@link #getAllCellInfo} instead, which returns a superset of this API. 1139 */ 1140 @Deprecated 1141 @RequiresPermission(anyOf = { 1142 android.Manifest.permission.ACCESS_COARSE_LOCATION, 1143 android.Manifest.permission.ACCESS_FINE_LOCATION 1144 }) getCellLocation()1145 public CellLocation getCellLocation() { 1146 try { 1147 ITelephony telephony = getITelephony(); 1148 if (telephony == null) { 1149 Rlog.d(TAG, "getCellLocation returning null because telephony is null"); 1150 return null; 1151 } 1152 Bundle bundle = telephony.getCellLocation(mContext.getOpPackageName()); 1153 if (bundle.isEmpty()) { 1154 Rlog.d(TAG, "getCellLocation returning null because bundle is empty"); 1155 return null; 1156 } 1157 CellLocation cl = CellLocation.newFromBundle(bundle); 1158 if (cl.isEmpty()) { 1159 Rlog.d(TAG, "getCellLocation returning null because CellLocation is empty"); 1160 return null; 1161 } 1162 return cl; 1163 } catch (RemoteException ex) { 1164 Rlog.d(TAG, "getCellLocation returning null due to RemoteException " + ex); 1165 return null; 1166 } catch (NullPointerException ex) { 1167 Rlog.d(TAG, "getCellLocation returning null due to NullPointerException " + ex); 1168 return null; 1169 } 1170 } 1171 1172 /** 1173 * Enables location update notifications. {@link PhoneStateListener#onCellLocationChanged 1174 * PhoneStateListener.onCellLocationChanged} will be called on location updates. 1175 * 1176 * @hide 1177 */ 1178 @RequiresPermission(android.Manifest.permission.CONTROL_LOCATION_UPDATES) enableLocationUpdates()1179 public void enableLocationUpdates() { 1180 enableLocationUpdates(getSubId()); 1181 } 1182 1183 /** 1184 * Enables location update notifications for a subscription. 1185 * {@link PhoneStateListener#onCellLocationChanged 1186 * PhoneStateListener.onCellLocationChanged} will be called on location updates. 1187 * 1188 * @param subId for which the location updates are enabled 1189 * @hide 1190 */ 1191 @RequiresPermission(android.Manifest.permission.CONTROL_LOCATION_UPDATES) enableLocationUpdates(int subId)1192 public void enableLocationUpdates(int subId) { 1193 try { 1194 ITelephony telephony = getITelephony(); 1195 if (telephony != null) 1196 telephony.enableLocationUpdatesForSubscriber(subId); 1197 } catch (RemoteException ex) { 1198 } catch (NullPointerException ex) { 1199 } 1200 } 1201 1202 /** 1203 * Disables location update notifications. {@link PhoneStateListener#onCellLocationChanged 1204 * PhoneStateListener.onCellLocationChanged} will be called on location updates. 1205 * 1206 * @hide 1207 */ 1208 @RequiresPermission(android.Manifest.permission.CONTROL_LOCATION_UPDATES) disableLocationUpdates()1209 public void disableLocationUpdates() { 1210 disableLocationUpdates(getSubId()); 1211 } 1212 1213 /** @hide */ disableLocationUpdates(int subId)1214 public void disableLocationUpdates(int subId) { 1215 try { 1216 ITelephony telephony = getITelephony(); 1217 if (telephony != null) 1218 telephony.disableLocationUpdatesForSubscriber(subId); 1219 } catch (RemoteException ex) { 1220 } catch (NullPointerException ex) { 1221 } 1222 } 1223 1224 /** 1225 * Returns the neighboring cell information of the device. 1226 * 1227 * @return List of NeighboringCellInfo or null if info unavailable. 1228 * 1229 * @deprecated Use {@link #getAllCellInfo} which returns a superset of the information 1230 * from NeighboringCellInfo. 1231 */ 1232 @Deprecated 1233 @RequiresPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION) getNeighboringCellInfo()1234 public List<NeighboringCellInfo> getNeighboringCellInfo() { 1235 try { 1236 ITelephony telephony = getITelephony(); 1237 if (telephony == null) 1238 return null; 1239 return telephony.getNeighboringCellInfo(mContext.getOpPackageName()); 1240 } catch (RemoteException ex) { 1241 return null; 1242 } catch (NullPointerException ex) { 1243 return null; 1244 } 1245 } 1246 1247 /** No phone radio. */ 1248 public static final int PHONE_TYPE_NONE = PhoneConstants.PHONE_TYPE_NONE; 1249 /** Phone radio is GSM. */ 1250 public static final int PHONE_TYPE_GSM = PhoneConstants.PHONE_TYPE_GSM; 1251 /** Phone radio is CDMA. */ 1252 public static final int PHONE_TYPE_CDMA = PhoneConstants.PHONE_TYPE_CDMA; 1253 /** Phone is via SIP. */ 1254 public static final int PHONE_TYPE_SIP = PhoneConstants.PHONE_TYPE_SIP; 1255 1256 /** 1257 * Returns the current phone type. 1258 * TODO: This is a last minute change and hence hidden. 1259 * 1260 * @see #PHONE_TYPE_NONE 1261 * @see #PHONE_TYPE_GSM 1262 * @see #PHONE_TYPE_CDMA 1263 * @see #PHONE_TYPE_SIP 1264 * 1265 * {@hide} 1266 */ 1267 @SystemApi getCurrentPhoneType()1268 public int getCurrentPhoneType() { 1269 return getCurrentPhoneType(getSubId()); 1270 } 1271 1272 /** 1273 * Returns a constant indicating the device phone type for a subscription. 1274 * 1275 * @see #PHONE_TYPE_NONE 1276 * @see #PHONE_TYPE_GSM 1277 * @see #PHONE_TYPE_CDMA 1278 * 1279 * @param subId for which phone type is returned 1280 * @hide 1281 */ 1282 @SystemApi getCurrentPhoneType(int subId)1283 public int getCurrentPhoneType(int subId) { 1284 int phoneId; 1285 if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { 1286 // if we don't have any sims, we don't have subscriptions, but we 1287 // still may want to know what type of phone we've got. 1288 phoneId = 0; 1289 } else { 1290 phoneId = SubscriptionManager.getPhoneId(subId); 1291 } 1292 1293 return getCurrentPhoneTypeForSlot(phoneId); 1294 } 1295 1296 /** 1297 * See getCurrentPhoneType. 1298 * 1299 * @hide 1300 */ getCurrentPhoneTypeForSlot(int slotIndex)1301 public int getCurrentPhoneTypeForSlot(int slotIndex) { 1302 try{ 1303 ITelephony telephony = getITelephony(); 1304 if (telephony != null) { 1305 return telephony.getActivePhoneTypeForSlot(slotIndex); 1306 } else { 1307 // This can happen when the ITelephony interface is not up yet. 1308 return getPhoneTypeFromProperty(slotIndex); 1309 } 1310 } catch (RemoteException ex) { 1311 // This shouldn't happen in the normal case, as a backup we 1312 // read from the system property. 1313 return getPhoneTypeFromProperty(slotIndex); 1314 } catch (NullPointerException ex) { 1315 // This shouldn't happen in the normal case, as a backup we 1316 // read from the system property. 1317 return getPhoneTypeFromProperty(slotIndex); 1318 } 1319 } 1320 1321 /** 1322 * Returns a constant indicating the device phone type. This 1323 * indicates the type of radio used to transmit voice calls. 1324 * 1325 * @see #PHONE_TYPE_NONE 1326 * @see #PHONE_TYPE_GSM 1327 * @see #PHONE_TYPE_CDMA 1328 * @see #PHONE_TYPE_SIP 1329 */ getPhoneType()1330 public int getPhoneType() { 1331 if (!isVoiceCapable()) { 1332 return PHONE_TYPE_NONE; 1333 } 1334 return getCurrentPhoneType(); 1335 } 1336 getPhoneTypeFromProperty()1337 private int getPhoneTypeFromProperty() { 1338 return getPhoneTypeFromProperty(getPhoneId()); 1339 } 1340 1341 /** {@hide} */ getPhoneTypeFromProperty(int phoneId)1342 private int getPhoneTypeFromProperty(int phoneId) { 1343 String type = getTelephonyProperty(phoneId, 1344 TelephonyProperties.CURRENT_ACTIVE_PHONE, null); 1345 if (type == null || type.isEmpty()) { 1346 return getPhoneTypeFromNetworkType(phoneId); 1347 } 1348 return Integer.parseInt(type); 1349 } 1350 getPhoneTypeFromNetworkType()1351 private int getPhoneTypeFromNetworkType() { 1352 return getPhoneTypeFromNetworkType(getPhoneId()); 1353 } 1354 1355 /** {@hide} */ getPhoneTypeFromNetworkType(int phoneId)1356 private int getPhoneTypeFromNetworkType(int phoneId) { 1357 // When the system property CURRENT_ACTIVE_PHONE, has not been set, 1358 // use the system property for default network type. 1359 // This is a fail safe, and can only happen at first boot. 1360 String mode = getTelephonyProperty(phoneId, "ro.telephony.default_network", null); 1361 if (mode != null && !mode.isEmpty()) { 1362 return TelephonyManager.getPhoneType(Integer.parseInt(mode)); 1363 } 1364 return TelephonyManager.PHONE_TYPE_NONE; 1365 } 1366 1367 /** 1368 * This function returns the type of the phone, depending 1369 * on the network mode. 1370 * 1371 * @param networkMode 1372 * @return Phone Type 1373 * 1374 * @hide 1375 */ getPhoneType(int networkMode)1376 public static int getPhoneType(int networkMode) { 1377 switch(networkMode) { 1378 case RILConstants.NETWORK_MODE_CDMA: 1379 case RILConstants.NETWORK_MODE_CDMA_NO_EVDO: 1380 case RILConstants.NETWORK_MODE_EVDO_NO_CDMA: 1381 return PhoneConstants.PHONE_TYPE_CDMA; 1382 1383 case RILConstants.NETWORK_MODE_WCDMA_PREF: 1384 case RILConstants.NETWORK_MODE_GSM_ONLY: 1385 case RILConstants.NETWORK_MODE_WCDMA_ONLY: 1386 case RILConstants.NETWORK_MODE_GSM_UMTS: 1387 case RILConstants.NETWORK_MODE_LTE_GSM_WCDMA: 1388 case RILConstants.NETWORK_MODE_LTE_WCDMA: 1389 case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1390 case RILConstants.NETWORK_MODE_TDSCDMA_ONLY: 1391 case RILConstants.NETWORK_MODE_TDSCDMA_WCDMA: 1392 case RILConstants.NETWORK_MODE_LTE_TDSCDMA: 1393 case RILConstants.NETWORK_MODE_TDSCDMA_GSM: 1394 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: 1395 case RILConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA: 1396 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: 1397 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: 1398 case RILConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1399 return PhoneConstants.PHONE_TYPE_GSM; 1400 1401 // Use CDMA Phone for the global mode including CDMA 1402 case RILConstants.NETWORK_MODE_GLOBAL: 1403 case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO: 1404 case RILConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1405 return PhoneConstants.PHONE_TYPE_CDMA; 1406 1407 case RILConstants.NETWORK_MODE_LTE_ONLY: 1408 if (getLteOnCdmaModeStatic() == PhoneConstants.LTE_ON_CDMA_TRUE) { 1409 return PhoneConstants.PHONE_TYPE_CDMA; 1410 } else { 1411 return PhoneConstants.PHONE_TYPE_GSM; 1412 } 1413 default: 1414 return PhoneConstants.PHONE_TYPE_GSM; 1415 } 1416 } 1417 1418 /** 1419 * The contents of the /proc/cmdline file 1420 */ getProcCmdLine()1421 private static String getProcCmdLine() 1422 { 1423 String cmdline = ""; 1424 FileInputStream is = null; 1425 try { 1426 is = new FileInputStream("/proc/cmdline"); 1427 byte [] buffer = new byte[2048]; 1428 int count = is.read(buffer); 1429 if (count > 0) { 1430 cmdline = new String(buffer, 0, count); 1431 } 1432 } catch (IOException e) { 1433 Rlog.d(TAG, "No /proc/cmdline exception=" + e); 1434 } finally { 1435 if (is != null) { 1436 try { 1437 is.close(); 1438 } catch (IOException e) { 1439 } 1440 } 1441 } 1442 Rlog.d(TAG, "/proc/cmdline=" + cmdline); 1443 return cmdline; 1444 } 1445 1446 /** Kernel command line */ 1447 private static final String sKernelCmdLine = getProcCmdLine(); 1448 1449 /** Pattern for selecting the product type from the kernel command line */ 1450 private static final Pattern sProductTypePattern = 1451 Pattern.compile("\\sproduct_type\\s*=\\s*(\\w+)"); 1452 1453 /** The ProductType used for LTE on CDMA devices */ 1454 private static final String sLteOnCdmaProductType = 1455 SystemProperties.get(TelephonyProperties.PROPERTY_LTE_ON_CDMA_PRODUCT_TYPE, ""); 1456 1457 /** 1458 * Return if the current radio is LTE on CDMA. This 1459 * is a tri-state return value as for a period of time 1460 * the mode may be unknown. 1461 * 1462 * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE} 1463 * or {@link PhoneConstants#LTE_ON_CDMA_TRUE} 1464 * 1465 * @hide 1466 */ getLteOnCdmaModeStatic()1467 public static int getLteOnCdmaModeStatic() { 1468 int retVal; 1469 int curVal; 1470 String productType = ""; 1471 1472 curVal = SystemProperties.getInt(TelephonyProperties.PROPERTY_LTE_ON_CDMA_DEVICE, 1473 PhoneConstants.LTE_ON_CDMA_UNKNOWN); 1474 retVal = curVal; 1475 if (retVal == PhoneConstants.LTE_ON_CDMA_UNKNOWN) { 1476 Matcher matcher = sProductTypePattern.matcher(sKernelCmdLine); 1477 if (matcher.find()) { 1478 productType = matcher.group(1); 1479 if (sLteOnCdmaProductType.equals(productType)) { 1480 retVal = PhoneConstants.LTE_ON_CDMA_TRUE; 1481 } else { 1482 retVal = PhoneConstants.LTE_ON_CDMA_FALSE; 1483 } 1484 } else { 1485 retVal = PhoneConstants.LTE_ON_CDMA_FALSE; 1486 } 1487 } 1488 1489 Rlog.d(TAG, "getLteOnCdmaMode=" + retVal + " curVal=" + curVal + 1490 " product_type='" + productType + 1491 "' lteOnCdmaProductType='" + sLteOnCdmaProductType + "'"); 1492 return retVal; 1493 } 1494 1495 // 1496 // 1497 // Current Network 1498 // 1499 // 1500 1501 /** 1502 * Returns the alphabetic name of current registered operator. 1503 * <p> 1504 * Availability: Only when user is registered to a network. Result may be 1505 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1506 * on a CDMA network). 1507 */ getNetworkOperatorName()1508 public String getNetworkOperatorName() { 1509 return getNetworkOperatorName(getSubId()); 1510 } 1511 1512 /** 1513 * Returns the alphabetic name of current registered operator 1514 * for a particular subscription. 1515 * <p> 1516 * Availability: Only when user is registered to a network. Result may be 1517 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1518 * on a CDMA network). 1519 * @param subId 1520 * @hide 1521 */ getNetworkOperatorName(int subId)1522 public String getNetworkOperatorName(int subId) { 1523 int phoneId = SubscriptionManager.getPhoneId(subId); 1524 return getTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ALPHA, ""); 1525 } 1526 1527 /** 1528 * Returns the numeric name (MCC+MNC) of current registered operator. 1529 * <p> 1530 * Availability: Only when user is registered to a network. Result may be 1531 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1532 * on a CDMA network). 1533 */ getNetworkOperator()1534 public String getNetworkOperator() { 1535 return getNetworkOperatorForPhone(getPhoneId()); 1536 } 1537 1538 /** 1539 * Returns the numeric name (MCC+MNC) of current registered operator 1540 * for a particular subscription. 1541 * <p> 1542 * Availability: Only when user is registered to a network. Result may be 1543 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1544 * on a CDMA network). 1545 * 1546 * @param subId 1547 * @hide 1548 */ getNetworkOperator(int subId)1549 public String getNetworkOperator(int subId) { 1550 int phoneId = SubscriptionManager.getPhoneId(subId); 1551 return getNetworkOperatorForPhone(phoneId); 1552 } 1553 1554 /** 1555 * Returns the numeric name (MCC+MNC) of current registered operator 1556 * for a particular subscription. 1557 * <p> 1558 * Availability: Only when user is registered to a network. Result may be 1559 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1560 * on a CDMA network). 1561 * 1562 * @param phoneId 1563 * @hide 1564 **/ getNetworkOperatorForPhone(int phoneId)1565 public String getNetworkOperatorForPhone(int phoneId) { 1566 return getTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, ""); 1567 } 1568 1569 1570 /** 1571 * Returns the network specifier of the subscription ID pinned to the TelephonyManager. The 1572 * network specifier is used by {@link 1573 * android.net.NetworkRequest.Builder#setNetworkSpecifier(String)} to create a {@link 1574 * android.net.NetworkRequest} that connects through the subscription. 1575 * 1576 * @see android.net.NetworkRequest.Builder#setNetworkSpecifier(String) 1577 * @see #createForSubscriptionId(int) 1578 * @see #createForPhoneAccountHandle(PhoneAccountHandle) 1579 */ getNetworkSpecifier()1580 public String getNetworkSpecifier() { 1581 return String.valueOf(getSubId()); 1582 } 1583 1584 /** 1585 * Returns the carrier config of the subscription ID pinned to the TelephonyManager. If an 1586 * invalid subscription ID is pinned to the TelephonyManager, the returned config will contain 1587 * default values. 1588 * 1589 * @see CarrierConfigManager#getConfigForSubId(int) 1590 * @see #createForSubscriptionId(int) 1591 * @see #createForPhoneAccountHandle(PhoneAccountHandle) 1592 */ 1593 @WorkerThread 1594 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCarrierConfig()1595 public PersistableBundle getCarrierConfig() { 1596 CarrierConfigManager carrierConfigManager = mContext 1597 .getSystemService(CarrierConfigManager.class); 1598 return carrierConfigManager.getConfigForSubId(getSubId()); 1599 } 1600 1601 /** 1602 * Returns true if the device is considered roaming on the current 1603 * network, for GSM purposes. 1604 * <p> 1605 * Availability: Only when user registered to a network. 1606 */ isNetworkRoaming()1607 public boolean isNetworkRoaming() { 1608 return isNetworkRoaming(getSubId()); 1609 } 1610 1611 /** 1612 * Returns true if the device is considered roaming on the current 1613 * network for a subscription. 1614 * <p> 1615 * Availability: Only when user registered to a network. 1616 * 1617 * @param subId 1618 * @hide 1619 */ isNetworkRoaming(int subId)1620 public boolean isNetworkRoaming(int subId) { 1621 int phoneId = SubscriptionManager.getPhoneId(subId); 1622 return Boolean.parseBoolean(getTelephonyProperty(phoneId, 1623 TelephonyProperties.PROPERTY_OPERATOR_ISROAMING, null)); 1624 } 1625 1626 /** 1627 * Returns the ISO country code equivalent of the current registered 1628 * operator's MCC (Mobile Country Code). 1629 * <p> 1630 * Availability: Only when user is registered to a network. Result may be 1631 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1632 * on a CDMA network). 1633 */ getNetworkCountryIso()1634 public String getNetworkCountryIso() { 1635 return getNetworkCountryIsoForPhone(getPhoneId()); 1636 } 1637 1638 /** 1639 * Returns the ISO country code equivalent of the current registered 1640 * operator's MCC (Mobile Country Code) of a subscription. 1641 * <p> 1642 * Availability: Only when user is registered to a network. Result may be 1643 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1644 * on a CDMA network). 1645 * 1646 * @param subId for which Network CountryIso is returned 1647 * @hide 1648 */ getNetworkCountryIso(int subId)1649 public String getNetworkCountryIso(int subId) { 1650 return getNetworkCountryIsoForPhone(getPhoneId(subId)); 1651 } 1652 1653 /** 1654 * Returns the ISO country code equivalent of the current registered 1655 * operator's MCC (Mobile Country Code) of a subscription. 1656 * <p> 1657 * Availability: Only when user is registered to a network. Result may be 1658 * unreliable on CDMA networks (use {@link #getPhoneType()} to determine if 1659 * on a CDMA network). 1660 * 1661 * @param phoneId for which Network CountryIso is returned 1662 */ 1663 /** {@hide} */ getNetworkCountryIsoForPhone(int phoneId)1664 public String getNetworkCountryIsoForPhone(int phoneId) { 1665 try { 1666 ITelephony telephony = getITelephony(); 1667 if (telephony == null) 1668 return ""; 1669 return telephony.getNetworkCountryIsoForPhone(phoneId); 1670 } catch (RemoteException ex) { 1671 return ""; 1672 } 1673 } 1674 1675 /** Network type is unknown */ 1676 public static final int NETWORK_TYPE_UNKNOWN = 0; 1677 /** Current network is GPRS */ 1678 public static final int NETWORK_TYPE_GPRS = 1; 1679 /** Current network is EDGE */ 1680 public static final int NETWORK_TYPE_EDGE = 2; 1681 /** Current network is UMTS */ 1682 public static final int NETWORK_TYPE_UMTS = 3; 1683 /** Current network is CDMA: Either IS95A or IS95B*/ 1684 public static final int NETWORK_TYPE_CDMA = 4; 1685 /** Current network is EVDO revision 0*/ 1686 public static final int NETWORK_TYPE_EVDO_0 = 5; 1687 /** Current network is EVDO revision A*/ 1688 public static final int NETWORK_TYPE_EVDO_A = 6; 1689 /** Current network is 1xRTT*/ 1690 public static final int NETWORK_TYPE_1xRTT = 7; 1691 /** Current network is HSDPA */ 1692 public static final int NETWORK_TYPE_HSDPA = 8; 1693 /** Current network is HSUPA */ 1694 public static final int NETWORK_TYPE_HSUPA = 9; 1695 /** Current network is HSPA */ 1696 public static final int NETWORK_TYPE_HSPA = 10; 1697 /** Current network is iDen */ 1698 public static final int NETWORK_TYPE_IDEN = 11; 1699 /** Current network is EVDO revision B*/ 1700 public static final int NETWORK_TYPE_EVDO_B = 12; 1701 /** Current network is LTE */ 1702 public static final int NETWORK_TYPE_LTE = 13; 1703 /** Current network is eHRPD */ 1704 public static final int NETWORK_TYPE_EHRPD = 14; 1705 /** Current network is HSPA+ */ 1706 public static final int NETWORK_TYPE_HSPAP = 15; 1707 /** Current network is GSM */ 1708 public static final int NETWORK_TYPE_GSM = 16; 1709 /** Current network is TD_SCDMA */ 1710 public static final int NETWORK_TYPE_TD_SCDMA = 17; 1711 /** Current network is IWLAN */ 1712 public static final int NETWORK_TYPE_IWLAN = 18; 1713 /** Current network is LTE_CA {@hide} */ 1714 public static final int NETWORK_TYPE_LTE_CA = 19; 1715 /** 1716 * @return the NETWORK_TYPE_xxxx for current data connection. 1717 */ getNetworkType()1718 public int getNetworkType() { 1719 try { 1720 ITelephony telephony = getITelephony(); 1721 if (telephony != null) { 1722 return telephony.getNetworkType(); 1723 } else { 1724 // This can happen when the ITelephony interface is not up yet. 1725 return NETWORK_TYPE_UNKNOWN; 1726 } 1727 } catch(RemoteException ex) { 1728 // This shouldn't happen in the normal case 1729 return NETWORK_TYPE_UNKNOWN; 1730 } catch (NullPointerException ex) { 1731 // This could happen before phone restarts due to crashing 1732 return NETWORK_TYPE_UNKNOWN; 1733 } 1734 } 1735 1736 /** 1737 * Returns a constant indicating the radio technology (network type) 1738 * currently in use on the device for a subscription. 1739 * @return the network type 1740 * 1741 * @param subId for which network type is returned 1742 * 1743 * @see #NETWORK_TYPE_UNKNOWN 1744 * @see #NETWORK_TYPE_GPRS 1745 * @see #NETWORK_TYPE_EDGE 1746 * @see #NETWORK_TYPE_UMTS 1747 * @see #NETWORK_TYPE_HSDPA 1748 * @see #NETWORK_TYPE_HSUPA 1749 * @see #NETWORK_TYPE_HSPA 1750 * @see #NETWORK_TYPE_CDMA 1751 * @see #NETWORK_TYPE_EVDO_0 1752 * @see #NETWORK_TYPE_EVDO_A 1753 * @see #NETWORK_TYPE_EVDO_B 1754 * @see #NETWORK_TYPE_1xRTT 1755 * @see #NETWORK_TYPE_IDEN 1756 * @see #NETWORK_TYPE_LTE 1757 * @see #NETWORK_TYPE_EHRPD 1758 * @see #NETWORK_TYPE_HSPAP 1759 * 1760 * @hide 1761 */ 1762 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getNetworkType(int subId)1763 public int getNetworkType(int subId) { 1764 try { 1765 ITelephony telephony = getITelephony(); 1766 if (telephony != null) { 1767 return telephony.getNetworkTypeForSubscriber(subId, getOpPackageName()); 1768 } else { 1769 // This can happen when the ITelephony interface is not up yet. 1770 return NETWORK_TYPE_UNKNOWN; 1771 } 1772 } catch(RemoteException ex) { 1773 // This shouldn't happen in the normal case 1774 return NETWORK_TYPE_UNKNOWN; 1775 } catch (NullPointerException ex) { 1776 // This could happen before phone restarts due to crashing 1777 return NETWORK_TYPE_UNKNOWN; 1778 } 1779 } 1780 1781 /** 1782 * Returns a constant indicating the radio technology (network type) 1783 * currently in use on the device for data transmission. 1784 * 1785 * If this object has been created with {@link #createForSubscriptionId}, applies to the given 1786 * subId. Otherwise, applies to {@link SubscriptionManager#getDefaultDataSubscriptionId()} 1787 * 1788 * @return the network type 1789 * 1790 * @see #NETWORK_TYPE_UNKNOWN 1791 * @see #NETWORK_TYPE_GPRS 1792 * @see #NETWORK_TYPE_EDGE 1793 * @see #NETWORK_TYPE_UMTS 1794 * @see #NETWORK_TYPE_HSDPA 1795 * @see #NETWORK_TYPE_HSUPA 1796 * @see #NETWORK_TYPE_HSPA 1797 * @see #NETWORK_TYPE_CDMA 1798 * @see #NETWORK_TYPE_EVDO_0 1799 * @see #NETWORK_TYPE_EVDO_A 1800 * @see #NETWORK_TYPE_EVDO_B 1801 * @see #NETWORK_TYPE_1xRTT 1802 * @see #NETWORK_TYPE_IDEN 1803 * @see #NETWORK_TYPE_LTE 1804 * @see #NETWORK_TYPE_EHRPD 1805 * @see #NETWORK_TYPE_HSPAP 1806 */ 1807 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDataNetworkType()1808 public int getDataNetworkType() { 1809 return getDataNetworkType(getSubId(SubscriptionManager.getDefaultDataSubscriptionId())); 1810 } 1811 1812 /** 1813 * Returns a constant indicating the radio technology (network type) 1814 * currently in use on the device for data transmission for a subscription 1815 * @return the network type 1816 * 1817 * @param subId for which network type is returned 1818 * @hide 1819 */ 1820 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDataNetworkType(int subId)1821 public int getDataNetworkType(int subId) { 1822 try{ 1823 ITelephony telephony = getITelephony(); 1824 if (telephony != null) { 1825 return telephony.getDataNetworkTypeForSubscriber(subId, getOpPackageName()); 1826 } else { 1827 // This can happen when the ITelephony interface is not up yet. 1828 return NETWORK_TYPE_UNKNOWN; 1829 } 1830 } catch(RemoteException ex) { 1831 // This shouldn't happen in the normal case 1832 return NETWORK_TYPE_UNKNOWN; 1833 } catch (NullPointerException ex) { 1834 // This could happen before phone restarts due to crashing 1835 return NETWORK_TYPE_UNKNOWN; 1836 } 1837 } 1838 1839 /** 1840 * Returns the NETWORK_TYPE_xxxx for voice 1841 */ 1842 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceNetworkType()1843 public int getVoiceNetworkType() { 1844 return getVoiceNetworkType(getSubId()); 1845 } 1846 1847 /** 1848 * Returns the NETWORK_TYPE_xxxx for voice for a subId 1849 * @hide 1850 */ 1851 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceNetworkType(int subId)1852 public int getVoiceNetworkType(int subId) { 1853 try{ 1854 ITelephony telephony = getITelephony(); 1855 if (telephony != null) { 1856 return telephony.getVoiceNetworkTypeForSubscriber(subId, getOpPackageName()); 1857 } else { 1858 // This can happen when the ITelephony interface is not up yet. 1859 return NETWORK_TYPE_UNKNOWN; 1860 } 1861 } catch(RemoteException ex) { 1862 // This shouldn't happen in the normal case 1863 return NETWORK_TYPE_UNKNOWN; 1864 } catch (NullPointerException ex) { 1865 // This could happen before phone restarts due to crashing 1866 return NETWORK_TYPE_UNKNOWN; 1867 } 1868 } 1869 1870 /** 1871 * Network Class Definitions. 1872 * Do not change this order, it is used for sorting during emergency calling in 1873 * {@link TelephonyConnectionService#getFirstPhoneForEmergencyCall()}. Any newer technologies 1874 * should be added after the current definitions. 1875 */ 1876 /** Unknown network class. {@hide} */ 1877 public static final int NETWORK_CLASS_UNKNOWN = 0; 1878 /** Class of broadly defined "2G" networks. {@hide} */ 1879 public static final int NETWORK_CLASS_2_G = 1; 1880 /** Class of broadly defined "3G" networks. {@hide} */ 1881 public static final int NETWORK_CLASS_3_G = 2; 1882 /** Class of broadly defined "4G" networks. {@hide} */ 1883 public static final int NETWORK_CLASS_4_G = 3; 1884 1885 /** 1886 * Return general class of network type, such as "3G" or "4G". In cases 1887 * where classification is contentious, this method is conservative. 1888 * 1889 * @hide 1890 */ getNetworkClass(int networkType)1891 public static int getNetworkClass(int networkType) { 1892 switch (networkType) { 1893 case NETWORK_TYPE_GPRS: 1894 case NETWORK_TYPE_GSM: 1895 case NETWORK_TYPE_EDGE: 1896 case NETWORK_TYPE_CDMA: 1897 case NETWORK_TYPE_1xRTT: 1898 case NETWORK_TYPE_IDEN: 1899 return NETWORK_CLASS_2_G; 1900 case NETWORK_TYPE_UMTS: 1901 case NETWORK_TYPE_EVDO_0: 1902 case NETWORK_TYPE_EVDO_A: 1903 case NETWORK_TYPE_HSDPA: 1904 case NETWORK_TYPE_HSUPA: 1905 case NETWORK_TYPE_HSPA: 1906 case NETWORK_TYPE_EVDO_B: 1907 case NETWORK_TYPE_EHRPD: 1908 case NETWORK_TYPE_HSPAP: 1909 case NETWORK_TYPE_TD_SCDMA: 1910 return NETWORK_CLASS_3_G; 1911 case NETWORK_TYPE_LTE: 1912 case NETWORK_TYPE_IWLAN: 1913 case NETWORK_TYPE_LTE_CA: 1914 return NETWORK_CLASS_4_G; 1915 default: 1916 return NETWORK_CLASS_UNKNOWN; 1917 } 1918 } 1919 1920 /** 1921 * Returns a string representation of the radio technology (network type) 1922 * currently in use on the device. 1923 * @return the name of the radio technology 1924 * 1925 * @hide pending API council review 1926 */ getNetworkTypeName()1927 public String getNetworkTypeName() { 1928 return getNetworkTypeName(getNetworkType()); 1929 } 1930 1931 /** 1932 * Returns a string representation of the radio technology (network type) 1933 * currently in use on the device. 1934 * @param subId for which network type is returned 1935 * @return the name of the radio technology 1936 * 1937 */ 1938 /** {@hide} */ getNetworkTypeName(int type)1939 public static String getNetworkTypeName(int type) { 1940 switch (type) { 1941 case NETWORK_TYPE_GPRS: 1942 return "GPRS"; 1943 case NETWORK_TYPE_EDGE: 1944 return "EDGE"; 1945 case NETWORK_TYPE_UMTS: 1946 return "UMTS"; 1947 case NETWORK_TYPE_HSDPA: 1948 return "HSDPA"; 1949 case NETWORK_TYPE_HSUPA: 1950 return "HSUPA"; 1951 case NETWORK_TYPE_HSPA: 1952 return "HSPA"; 1953 case NETWORK_TYPE_CDMA: 1954 return "CDMA"; 1955 case NETWORK_TYPE_EVDO_0: 1956 return "CDMA - EvDo rev. 0"; 1957 case NETWORK_TYPE_EVDO_A: 1958 return "CDMA - EvDo rev. A"; 1959 case NETWORK_TYPE_EVDO_B: 1960 return "CDMA - EvDo rev. B"; 1961 case NETWORK_TYPE_1xRTT: 1962 return "CDMA - 1xRTT"; 1963 case NETWORK_TYPE_LTE: 1964 return "LTE"; 1965 case NETWORK_TYPE_EHRPD: 1966 return "CDMA - eHRPD"; 1967 case NETWORK_TYPE_IDEN: 1968 return "iDEN"; 1969 case NETWORK_TYPE_HSPAP: 1970 return "HSPA+"; 1971 case NETWORK_TYPE_GSM: 1972 return "GSM"; 1973 case NETWORK_TYPE_TD_SCDMA: 1974 return "TD_SCDMA"; 1975 case NETWORK_TYPE_IWLAN: 1976 return "IWLAN"; 1977 case NETWORK_TYPE_LTE_CA: 1978 return "LTE_CA"; 1979 default: 1980 return "UNKNOWN"; 1981 } 1982 } 1983 1984 // 1985 // 1986 // SIM Card 1987 // 1988 // 1989 1990 /** 1991 * SIM card state: Unknown. Signifies that the SIM is in transition 1992 * between states. For example, when the user inputs the SIM pin 1993 * under PIN_REQUIRED state, a query for sim status returns 1994 * this state before turning to SIM_STATE_READY. 1995 * 1996 * These are the ordinal value of IccCardConstants.State. 1997 */ 1998 public static final int SIM_STATE_UNKNOWN = 0; 1999 /** SIM card state: no SIM card is available in the device */ 2000 public static final int SIM_STATE_ABSENT = 1; 2001 /** SIM card state: Locked: requires the user's SIM PIN to unlock */ 2002 public static final int SIM_STATE_PIN_REQUIRED = 2; 2003 /** SIM card state: Locked: requires the user's SIM PUK to unlock */ 2004 public static final int SIM_STATE_PUK_REQUIRED = 3; 2005 /** SIM card state: Locked: requires a network PIN to unlock */ 2006 public static final int SIM_STATE_NETWORK_LOCKED = 4; 2007 /** SIM card state: Ready */ 2008 public static final int SIM_STATE_READY = 5; 2009 /** SIM card state: SIM Card is NOT READY */ 2010 public static final int SIM_STATE_NOT_READY = 6; 2011 /** SIM card state: SIM Card Error, permanently disabled */ 2012 public static final int SIM_STATE_PERM_DISABLED = 7; 2013 /** SIM card state: SIM Card Error, present but faulty */ 2014 public static final int SIM_STATE_CARD_IO_ERROR = 8; 2015 /** SIM card state: SIM Card restricted, present but not usable due to 2016 * carrier restrictions. 2017 */ 2018 public static final int SIM_STATE_CARD_RESTRICTED = 9; 2019 2020 /** 2021 * @return true if a ICC card is present 2022 */ hasIccCard()2023 public boolean hasIccCard() { 2024 return hasIccCard(getSlotIndex()); 2025 } 2026 2027 /** 2028 * @return true if a ICC card is present for a subscription 2029 * 2030 * @param slotIndex for which icc card presence is checked 2031 */ 2032 /** {@hide} */ 2033 // FIXME Input argument slotIndex should be of type int hasIccCard(int slotIndex)2034 public boolean hasIccCard(int slotIndex) { 2035 2036 try { 2037 ITelephony telephony = getITelephony(); 2038 if (telephony == null) 2039 return false; 2040 return telephony.hasIccCardUsingSlotIndex(slotIndex); 2041 } catch (RemoteException ex) { 2042 // Assume no ICC card if remote exception which shouldn't happen 2043 return false; 2044 } catch (NullPointerException ex) { 2045 // This could happen before phone restarts due to crashing 2046 return false; 2047 } 2048 } 2049 2050 /** 2051 * Returns a constant indicating the state of the default SIM card. 2052 * 2053 * @see #SIM_STATE_UNKNOWN 2054 * @see #SIM_STATE_ABSENT 2055 * @see #SIM_STATE_PIN_REQUIRED 2056 * @see #SIM_STATE_PUK_REQUIRED 2057 * @see #SIM_STATE_NETWORK_LOCKED 2058 * @see #SIM_STATE_READY 2059 * @see #SIM_STATE_NOT_READY 2060 * @see #SIM_STATE_PERM_DISABLED 2061 * @see #SIM_STATE_CARD_IO_ERROR 2062 * @see #SIM_STATE_CARD_RESTRICTED 2063 */ getSimState()2064 public int getSimState() { 2065 int slotIndex = getSlotIndex(); 2066 // slotIndex may be invalid due to sim being absent. In that case query all slots to get 2067 // sim state 2068 if (slotIndex < 0) { 2069 // query for all slots and return absent if all sim states are absent, otherwise 2070 // return unknown 2071 for (int i = 0; i < getPhoneCount(); i++) { 2072 int simState = getSimState(i); 2073 if (simState != SIM_STATE_ABSENT) { 2074 Rlog.d(TAG, "getSimState: default sim:" + slotIndex + ", sim state for " + 2075 "slotIndex=" + i + " is " + simState + ", return state as unknown"); 2076 return SIM_STATE_UNKNOWN; 2077 } 2078 } 2079 Rlog.d(TAG, "getSimState: default sim:" + slotIndex + ", all SIMs absent, return " + 2080 "state as absent"); 2081 return SIM_STATE_ABSENT; 2082 } 2083 return getSimState(slotIndex); 2084 } 2085 2086 /** 2087 * Returns a constant indicating the state of the device SIM card in a slot. 2088 * 2089 * @param slotIndex 2090 * 2091 * @see #SIM_STATE_UNKNOWN 2092 * @see #SIM_STATE_ABSENT 2093 * @see #SIM_STATE_PIN_REQUIRED 2094 * @see #SIM_STATE_PUK_REQUIRED 2095 * @see #SIM_STATE_NETWORK_LOCKED 2096 * @see #SIM_STATE_READY 2097 * @see #SIM_STATE_NOT_READY 2098 * @see #SIM_STATE_PERM_DISABLED 2099 * @see #SIM_STATE_CARD_IO_ERROR 2100 * @see #SIM_STATE_CARD_RESTRICTED 2101 */ getSimState(int slotIndex)2102 public int getSimState(int slotIndex) { 2103 int simState = SubscriptionManager.getSimStateForSlotIndex(slotIndex); 2104 return simState; 2105 } 2106 2107 /** 2108 * Returns the MCC+MNC (mobile country code + mobile network code) of the 2109 * provider of the SIM. 5 or 6 decimal digits. 2110 * <p> 2111 * Availability: SIM state must be {@link #SIM_STATE_READY} 2112 * 2113 * @see #getSimState 2114 */ getSimOperator()2115 public String getSimOperator() { 2116 return getSimOperatorNumeric(); 2117 } 2118 2119 /** 2120 * Returns the MCC+MNC (mobile country code + mobile network code) of the 2121 * provider of the SIM. 5 or 6 decimal digits. 2122 * <p> 2123 * Availability: SIM state must be {@link #SIM_STATE_READY} 2124 * 2125 * @see #getSimState 2126 * 2127 * @param subId for which SimOperator is returned 2128 * @hide 2129 */ getSimOperator(int subId)2130 public String getSimOperator(int subId) { 2131 return getSimOperatorNumeric(subId); 2132 } 2133 2134 /** 2135 * Returns the MCC+MNC (mobile country code + mobile network code) of the 2136 * provider of the SIM. 5 or 6 decimal digits. 2137 * <p> 2138 * Availability: SIM state must be {@link #SIM_STATE_READY} 2139 * 2140 * @see #getSimState 2141 * @hide 2142 */ getSimOperatorNumeric()2143 public String getSimOperatorNumeric() { 2144 int subId = SubscriptionManager.getDefaultDataSubscriptionId(); 2145 if (!SubscriptionManager.isUsableSubIdValue(subId)) { 2146 subId = SubscriptionManager.getDefaultSmsSubscriptionId(); 2147 if (!SubscriptionManager.isUsableSubIdValue(subId)) { 2148 subId = SubscriptionManager.getDefaultVoiceSubscriptionId(); 2149 if (!SubscriptionManager.isUsableSubIdValue(subId)) { 2150 subId = SubscriptionManager.getDefaultSubscriptionId(); 2151 } 2152 } 2153 } 2154 return getSimOperatorNumeric(subId); 2155 } 2156 2157 /** 2158 * Returns the MCC+MNC (mobile country code + mobile network code) of the 2159 * provider of the SIM for a particular subscription. 5 or 6 decimal digits. 2160 * <p> 2161 * Availability: SIM state must be {@link #SIM_STATE_READY} 2162 * 2163 * @see #getSimState 2164 * 2165 * @param subId for which SimOperator is returned 2166 * @hide 2167 */ getSimOperatorNumeric(int subId)2168 public String getSimOperatorNumeric(int subId) { 2169 int phoneId = SubscriptionManager.getPhoneId(subId); 2170 return getSimOperatorNumericForPhone(phoneId); 2171 } 2172 2173 /** 2174 * Returns the MCC+MNC (mobile country code + mobile network code) of the 2175 * provider of the SIM for a particular subscription. 5 or 6 decimal digits. 2176 * <p> 2177 * 2178 * @param phoneId for which SimOperator is returned 2179 * @hide 2180 */ getSimOperatorNumericForPhone(int phoneId)2181 public String getSimOperatorNumericForPhone(int phoneId) { 2182 return getTelephonyProperty(phoneId, 2183 TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, ""); 2184 } 2185 2186 /** 2187 * Returns the Service Provider Name (SPN). 2188 * <p> 2189 * Availability: SIM state must be {@link #SIM_STATE_READY} 2190 * 2191 * @see #getSimState 2192 */ getSimOperatorName()2193 public String getSimOperatorName() { 2194 return getSimOperatorNameForPhone(getPhoneId()); 2195 } 2196 2197 /** 2198 * Returns the Service Provider Name (SPN). 2199 * <p> 2200 * Availability: SIM state must be {@link #SIM_STATE_READY} 2201 * 2202 * @see #getSimState 2203 * 2204 * @param subId for which SimOperatorName is returned 2205 * @hide 2206 */ getSimOperatorName(int subId)2207 public String getSimOperatorName(int subId) { 2208 int phoneId = SubscriptionManager.getPhoneId(subId); 2209 return getSimOperatorNameForPhone(phoneId); 2210 } 2211 2212 /** 2213 * Returns the Service Provider Name (SPN). 2214 * 2215 * @hide 2216 */ getSimOperatorNameForPhone(int phoneId)2217 public String getSimOperatorNameForPhone(int phoneId) { 2218 return getTelephonyProperty(phoneId, 2219 TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, ""); 2220 } 2221 2222 /** 2223 * Returns the ISO country code equivalent for the SIM provider's country code. 2224 */ getSimCountryIso()2225 public String getSimCountryIso() { 2226 return getSimCountryIsoForPhone(getPhoneId()); 2227 } 2228 2229 /** 2230 * Returns the ISO country code equivalent for the SIM provider's country code. 2231 * 2232 * @param subId for which SimCountryIso is returned 2233 * @hide 2234 */ getSimCountryIso(int subId)2235 public String getSimCountryIso(int subId) { 2236 int phoneId = SubscriptionManager.getPhoneId(subId); 2237 return getSimCountryIsoForPhone(phoneId); 2238 } 2239 2240 /** 2241 * Returns the ISO country code equivalent for the SIM provider's country code. 2242 * 2243 * @hide 2244 */ getSimCountryIsoForPhone(int phoneId)2245 public String getSimCountryIsoForPhone(int phoneId) { 2246 return getTelephonyProperty(phoneId, 2247 TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY, ""); 2248 } 2249 2250 /** 2251 * Returns the serial number of the SIM, if applicable. Return null if it is 2252 * unavailable. 2253 */ 2254 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getSimSerialNumber()2255 public String getSimSerialNumber() { 2256 return getSimSerialNumber(getSubId()); 2257 } 2258 2259 /** 2260 * Returns the serial number for the given subscription, if applicable. Return null if it is 2261 * unavailable. 2262 * <p> 2263 * @param subId for which Sim Serial number is returned 2264 * @hide 2265 */ 2266 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getSimSerialNumber(int subId)2267 public String getSimSerialNumber(int subId) { 2268 try { 2269 IPhoneSubInfo info = getSubscriberInfo(); 2270 if (info == null) 2271 return null; 2272 return info.getIccSerialNumberForSubscriber(subId, mContext.getOpPackageName()); 2273 } catch (RemoteException ex) { 2274 return null; 2275 } catch (NullPointerException ex) { 2276 // This could happen before phone restarts due to crashing 2277 return null; 2278 } 2279 } 2280 2281 /** 2282 * Return if the current radio is LTE on CDMA. This 2283 * is a tri-state return value as for a period of time 2284 * the mode may be unknown. 2285 * 2286 * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE} 2287 * or {@link PhoneConstants#LTE_ON_CDMA_TRUE} 2288 * 2289 * @hide 2290 */ 2291 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getLteOnCdmaMode()2292 public int getLteOnCdmaMode() { 2293 return getLteOnCdmaMode(getSubId()); 2294 } 2295 2296 /** 2297 * Return if the current radio is LTE on CDMA for Subscription. This 2298 * is a tri-state return value as for a period of time 2299 * the mode may be unknown. 2300 * 2301 * @param subId for which radio is LTE on CDMA is returned 2302 * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE} 2303 * or {@link PhoneConstants#LTE_ON_CDMA_TRUE} 2304 * @hide 2305 */ 2306 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getLteOnCdmaMode(int subId)2307 public int getLteOnCdmaMode(int subId) { 2308 try { 2309 ITelephony telephony = getITelephony(); 2310 if (telephony == null) 2311 return PhoneConstants.LTE_ON_CDMA_UNKNOWN; 2312 return telephony.getLteOnCdmaModeForSubscriber(subId, getOpPackageName()); 2313 } catch (RemoteException ex) { 2314 // Assume no ICC card if remote exception which shouldn't happen 2315 return PhoneConstants.LTE_ON_CDMA_UNKNOWN; 2316 } catch (NullPointerException ex) { 2317 // This could happen before phone restarts due to crashing 2318 return PhoneConstants.LTE_ON_CDMA_UNKNOWN; 2319 } 2320 } 2321 2322 // 2323 // 2324 // Subscriber Info 2325 // 2326 // 2327 2328 /** 2329 * Returns the unique subscriber ID, for example, the IMSI for a GSM phone. 2330 * Return null if it is unavailable. 2331 */ 2332 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getSubscriberId()2333 public String getSubscriberId() { 2334 return getSubscriberId(getSubId()); 2335 } 2336 2337 /** 2338 * Returns the unique subscriber ID, for example, the IMSI for a GSM phone 2339 * for a subscription. 2340 * Return null if it is unavailable. 2341 * 2342 * @param subId whose subscriber id is returned 2343 * @hide 2344 */ 2345 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getSubscriberId(int subId)2346 public String getSubscriberId(int subId) { 2347 try { 2348 IPhoneSubInfo info = getSubscriberInfo(); 2349 if (info == null) 2350 return null; 2351 return info.getSubscriberIdForSubscriber(subId, mContext.getOpPackageName()); 2352 } catch (RemoteException ex) { 2353 return null; 2354 } catch (NullPointerException ex) { 2355 // This could happen before phone restarts due to crashing 2356 return null; 2357 } 2358 } 2359 2360 /** 2361 * Returns Carrier specific information that will be used to encrypt the IMSI and IMPI. 2362 * This includes the public key and the key identifier. For multi-sim devices, if no subId 2363 * has been specified, we will return the value for the dafault data sim. 2364 * Return null if it is unavailable. 2365 * <p> 2366 * Requires Permission: 2367 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 2368 * @param keyType whether the key is being used for wlan or epdg. Valid key types are 2369 * {@link TelephonyManager#KEY_TYPE_EPDG} or 2370 * {@link TelephonyManager#KEY_TYPE_WLAN}. 2371 * @return ImsiEncryptionInfo Carrier specific information that will be used to encrypt the 2372 * IMSI and IMPI. This includes the public key and the key identifier. This information 2373 * will be stored in the device keystore. The system will return a null when no key was 2374 * found, and the carrier does not require a key. The system will throw the following 2375 * exceptions: 2376 * 1. IllegalArgumentException when an invalid key is sent. 2377 * 2. RuntimeException if the key is required but not found; and also if there was an 2378 * internal exception. 2379 * @hide 2380 */ getCarrierInfoForImsiEncryption(int keyType)2381 public ImsiEncryptionInfo getCarrierInfoForImsiEncryption(int keyType) { 2382 try { 2383 IPhoneSubInfo info = getSubscriberInfo(); 2384 if (info == null) { 2385 throw new RuntimeException("IMSI error: Subscriber Info is null"); 2386 } 2387 int subId = getSubId(SubscriptionManager.getDefaultDataSubscriptionId()); 2388 if (keyType != KEY_TYPE_EPDG && keyType != KEY_TYPE_WLAN) { 2389 throw new IllegalArgumentException("IMSI error: Invalid key type"); 2390 } 2391 ImsiEncryptionInfo imsiEncryptionInfo = info.getCarrierInfoForImsiEncryption( 2392 subId, keyType, mContext.getOpPackageName()); 2393 if (imsiEncryptionInfo == null 2394 && isImsiEncryptionRequired(subId, keyType)) { 2395 Rlog.e(TAG, "IMSI error: key is required but not found"); 2396 throw new RuntimeException("IMSI error: key is required but not found"); 2397 } 2398 return imsiEncryptionInfo; 2399 } catch (RemoteException ex) { 2400 Rlog.e(TAG, "getCarrierInfoForImsiEncryption RemoteException" + ex); 2401 throw new RuntimeException("IMSI error: Remote Exception"); 2402 } catch (NullPointerException ex) { 2403 // This could happen before phone restarts due to crashing 2404 Rlog.e(TAG, "getCarrierInfoForImsiEncryption NullPointerException" + ex); 2405 throw new RuntimeException("IMSI error: Null Pointer exception"); 2406 } 2407 } 2408 2409 /** 2410 * @param keyAvailability bitmask that defines the availabilty of keys for a type. 2411 * @param keyType the key type which is being checked. (WLAN, EPDG) 2412 * @return true if the digit at position keyType is 1, else false. 2413 * @hide 2414 */ isKeyEnabled(int keyAvailability, int keyType)2415 private static boolean isKeyEnabled(int keyAvailability, int keyType) { 2416 int returnValue = (keyAvailability >> (keyType - 1)) & 1; 2417 return (returnValue == 1) ? true : false; 2418 } 2419 2420 /** 2421 * If Carrier requires Imsi to be encrypted. 2422 * @hide 2423 */ isImsiEncryptionRequired(int subId, int keyType)2424 private boolean isImsiEncryptionRequired(int subId, int keyType) { 2425 CarrierConfigManager configManager = 2426 (CarrierConfigManager) mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE); 2427 if (configManager == null) { 2428 return false; 2429 } 2430 PersistableBundle pb = configManager.getConfigForSubId(subId); 2431 if (pb == null) { 2432 return false; 2433 } 2434 int keyAvailability = pb.getInt(CarrierConfigManager.IMSI_KEY_AVAILABILITY_INT); 2435 return isKeyEnabled(keyAvailability, keyType); 2436 } 2437 2438 /** 2439 * Sets the Carrier specific information that will be used to encrypt the IMSI and IMPI. 2440 * This includes the public key and the key identifier. This information will be stored in the 2441 * device keystore. 2442 * <p> 2443 * Requires Permission: 2444 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 2445 * @param imsiEncryptionInfo which includes the Key Type, the Public Key 2446 * (java.security.PublicKey) and the Key Identifier.and the Key Identifier. 2447 * The keyIdentifier Attribute value pair that helps a server locate 2448 * the private key to decrypt the permanent identity. This field is 2449 * optional and if it is present then it’s always separated from encrypted 2450 * permanent identity with “,”. Key identifier AVP is presented in ASCII string 2451 * with “name=value” format. 2452 * @hide 2453 */ setCarrierInfoForImsiEncryption(ImsiEncryptionInfo imsiEncryptionInfo)2454 public void setCarrierInfoForImsiEncryption(ImsiEncryptionInfo imsiEncryptionInfo) { 2455 try { 2456 IPhoneSubInfo info = getSubscriberInfo(); 2457 if (info == null) return; 2458 info.setCarrierInfoForImsiEncryption(mSubId, mContext.getOpPackageName(), 2459 imsiEncryptionInfo); 2460 } catch (NullPointerException ex) { 2461 // This could happen before phone restarts due to crashing 2462 return; 2463 } catch (RemoteException ex) { 2464 Rlog.e(TAG, "setCarrierInfoForImsiEncryption RemoteException", ex); 2465 return; 2466 } 2467 } 2468 2469 /** 2470 * Returns the Group Identifier Level1 for a GSM phone. 2471 * Return null if it is unavailable. 2472 */ 2473 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getGroupIdLevel1()2474 public String getGroupIdLevel1() { 2475 try { 2476 IPhoneSubInfo info = getSubscriberInfo(); 2477 if (info == null) 2478 return null; 2479 return info.getGroupIdLevel1(mContext.getOpPackageName()); 2480 } catch (RemoteException ex) { 2481 return null; 2482 } catch (NullPointerException ex) { 2483 // This could happen before phone restarts due to crashing 2484 return null; 2485 } 2486 } 2487 2488 /** 2489 * Returns the Group Identifier Level1 for a GSM phone for a particular subscription. 2490 * Return null if it is unavailable. 2491 * 2492 * @param subId whose subscriber id is returned 2493 * @hide 2494 */ 2495 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getGroupIdLevel1(int subId)2496 public String getGroupIdLevel1(int subId) { 2497 try { 2498 IPhoneSubInfo info = getSubscriberInfo(); 2499 if (info == null) 2500 return null; 2501 return info.getGroupIdLevel1ForSubscriber(subId, mContext.getOpPackageName()); 2502 } catch (RemoteException ex) { 2503 return null; 2504 } catch (NullPointerException ex) { 2505 // This could happen before phone restarts due to crashing 2506 return null; 2507 } 2508 } 2509 2510 /** 2511 * Returns the phone number string for line 1, for example, the MSISDN 2512 * for a GSM phone. Return null if it is unavailable. 2513 * <p> 2514 * The default SMS app can also use this. 2515 */ 2516 @RequiresPermission(anyOf = { 2517 android.Manifest.permission.READ_PHONE_STATE, 2518 android.Manifest.permission.READ_SMS, 2519 android.Manifest.permission.READ_PHONE_NUMBERS 2520 }) getLine1Number()2521 public String getLine1Number() { 2522 return getLine1Number(getSubId()); 2523 } 2524 2525 /** 2526 * Returns the phone number string for line 1, for example, the MSISDN 2527 * for a GSM phone for a particular subscription. Return null if it is unavailable. 2528 * <p> 2529 * The default SMS app can also use this. 2530 * 2531 * @param subId whose phone number for line 1 is returned 2532 * @hide 2533 */ 2534 @RequiresPermission(anyOf = { 2535 android.Manifest.permission.READ_PHONE_STATE, 2536 android.Manifest.permission.READ_SMS, 2537 android.Manifest.permission.READ_PHONE_NUMBERS 2538 }) getLine1Number(int subId)2539 public String getLine1Number(int subId) { 2540 String number = null; 2541 try { 2542 ITelephony telephony = getITelephony(); 2543 if (telephony != null) 2544 number = telephony.getLine1NumberForDisplay(subId, mContext.getOpPackageName()); 2545 } catch (RemoteException ex) { 2546 } catch (NullPointerException ex) { 2547 } 2548 if (number != null) { 2549 return number; 2550 } 2551 try { 2552 IPhoneSubInfo info = getSubscriberInfo(); 2553 if (info == null) 2554 return null; 2555 return info.getLine1NumberForSubscriber(subId, mContext.getOpPackageName()); 2556 } catch (RemoteException ex) { 2557 return null; 2558 } catch (NullPointerException ex) { 2559 // This could happen before phone restarts due to crashing 2560 return null; 2561 } 2562 } 2563 2564 /** 2565 * Set the line 1 phone number string and its alphatag for the current ICCID 2566 * for display purpose only, for example, displayed in Phone Status. It won't 2567 * change the actual MSISDN/MDN. To unset alphatag or number, pass in a null 2568 * value. 2569 * 2570 * <p>Requires that the calling app has carrier privileges. 2571 * @see #hasCarrierPrivileges 2572 * 2573 * @param alphaTag alpha-tagging of the dailing nubmer 2574 * @param number The dialing number 2575 * @return true if the operation was executed correctly. 2576 */ setLine1NumberForDisplay(String alphaTag, String number)2577 public boolean setLine1NumberForDisplay(String alphaTag, String number) { 2578 return setLine1NumberForDisplay(getSubId(), alphaTag, number); 2579 } 2580 2581 /** 2582 * Set the line 1 phone number string and its alphatag for the current ICCID 2583 * for display purpose only, for example, displayed in Phone Status. It won't 2584 * change the actual MSISDN/MDN. To unset alphatag or number, pass in a null 2585 * value. 2586 * 2587 * <p>Requires that the calling app has carrier privileges. 2588 * @see #hasCarrierPrivileges 2589 * 2590 * @param subId the subscriber that the alphatag and dialing number belongs to. 2591 * @param alphaTag alpha-tagging of the dailing nubmer 2592 * @param number The dialing number 2593 * @return true if the operation was executed correctly. 2594 * @hide 2595 */ setLine1NumberForDisplay(int subId, String alphaTag, String number)2596 public boolean setLine1NumberForDisplay(int subId, String alphaTag, String number) { 2597 try { 2598 ITelephony telephony = getITelephony(); 2599 if (telephony != null) 2600 return telephony.setLine1NumberForDisplayForSubscriber(subId, alphaTag, number); 2601 } catch (RemoteException ex) { 2602 } catch (NullPointerException ex) { 2603 } 2604 return false; 2605 } 2606 2607 /** 2608 * Returns the alphabetic identifier associated with the line 1 number. 2609 * Return null if it is unavailable. 2610 * @hide 2611 * nobody seems to call this. 2612 */ 2613 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getLine1AlphaTag()2614 public String getLine1AlphaTag() { 2615 return getLine1AlphaTag(getSubId()); 2616 } 2617 2618 /** 2619 * Returns the alphabetic identifier associated with the line 1 number 2620 * for a subscription. 2621 * Return null if it is unavailable. 2622 * @param subId whose alphabetic identifier associated with line 1 is returned 2623 * nobody seems to call this. 2624 * @hide 2625 */ 2626 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getLine1AlphaTag(int subId)2627 public String getLine1AlphaTag(int subId) { 2628 String alphaTag = null; 2629 try { 2630 ITelephony telephony = getITelephony(); 2631 if (telephony != null) 2632 alphaTag = telephony.getLine1AlphaTagForDisplay(subId, 2633 getOpPackageName()); 2634 } catch (RemoteException ex) { 2635 } catch (NullPointerException ex) { 2636 } 2637 if (alphaTag != null) { 2638 return alphaTag; 2639 } 2640 try { 2641 IPhoneSubInfo info = getSubscriberInfo(); 2642 if (info == null) 2643 return null; 2644 return info.getLine1AlphaTagForSubscriber(subId, getOpPackageName()); 2645 } catch (RemoteException ex) { 2646 return null; 2647 } catch (NullPointerException ex) { 2648 // This could happen before phone restarts due to crashing 2649 return null; 2650 } 2651 } 2652 2653 /** 2654 * Return the set of subscriber IDs that should be considered as "merged 2655 * together" for data usage purposes. This is commonly {@code null} to 2656 * indicate no merging is required. Any returned subscribers are sorted in a 2657 * deterministic order. 2658 * 2659 * @hide 2660 */ getMergedSubscriberIds()2661 public @Nullable String[] getMergedSubscriberIds() { 2662 try { 2663 ITelephony telephony = getITelephony(); 2664 if (telephony != null) 2665 return telephony.getMergedSubscriberIds(getOpPackageName()); 2666 } catch (RemoteException ex) { 2667 } catch (NullPointerException ex) { 2668 } 2669 return null; 2670 } 2671 2672 /** 2673 * Returns the MSISDN string. 2674 * for a GSM phone. Return null if it is unavailable. 2675 * 2676 * @hide 2677 */ 2678 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getMsisdn()2679 public String getMsisdn() { 2680 return getMsisdn(getSubId()); 2681 } 2682 2683 /** 2684 * Returns the MSISDN string. 2685 * for a GSM phone. Return null if it is unavailable. 2686 * 2687 * @param subId for which msisdn is returned 2688 * @hide 2689 */ 2690 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getMsisdn(int subId)2691 public String getMsisdn(int subId) { 2692 try { 2693 IPhoneSubInfo info = getSubscriberInfo(); 2694 if (info == null) 2695 return null; 2696 return info.getMsisdnForSubscriber(subId, getOpPackageName()); 2697 } catch (RemoteException ex) { 2698 return null; 2699 } catch (NullPointerException ex) { 2700 // This could happen before phone restarts due to crashing 2701 return null; 2702 } 2703 } 2704 2705 /** 2706 * Returns the voice mail number. Return null if it is unavailable. 2707 */ 2708 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMailNumber()2709 public String getVoiceMailNumber() { 2710 return getVoiceMailNumber(getSubId()); 2711 } 2712 2713 /** 2714 * Returns the voice mail number for a subscription. 2715 * Return null if it is unavailable. 2716 * @param subId whose voice mail number is returned 2717 * @hide 2718 */ 2719 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMailNumber(int subId)2720 public String getVoiceMailNumber(int subId) { 2721 try { 2722 IPhoneSubInfo info = getSubscriberInfo(); 2723 if (info == null) 2724 return null; 2725 return info.getVoiceMailNumberForSubscriber(subId, getOpPackageName()); 2726 } catch (RemoteException ex) { 2727 return null; 2728 } catch (NullPointerException ex) { 2729 // This could happen before phone restarts due to crashing 2730 return null; 2731 } 2732 } 2733 2734 /** 2735 * Returns the complete voice mail number. Return null if it is unavailable. 2736 * 2737 * @hide 2738 */ 2739 @RequiresPermission(android.Manifest.permission.CALL_PRIVILEGED) getCompleteVoiceMailNumber()2740 public String getCompleteVoiceMailNumber() { 2741 return getCompleteVoiceMailNumber(getSubId()); 2742 } 2743 2744 /** 2745 * Returns the complete voice mail number. Return null if it is unavailable. 2746 * 2747 * @param subId 2748 * @hide 2749 */ 2750 @RequiresPermission(android.Manifest.permission.CALL_PRIVILEGED) getCompleteVoiceMailNumber(int subId)2751 public String getCompleteVoiceMailNumber(int subId) { 2752 try { 2753 IPhoneSubInfo info = getSubscriberInfo(); 2754 if (info == null) 2755 return null; 2756 return info.getCompleteVoiceMailNumberForSubscriber(subId); 2757 } catch (RemoteException ex) { 2758 return null; 2759 } catch (NullPointerException ex) { 2760 // This could happen before phone restarts due to crashing 2761 return null; 2762 } 2763 } 2764 2765 /** 2766 * Sets the voice mail number. 2767 * 2768 * <p>Requires that the calling app has carrier privileges. 2769 * @see #hasCarrierPrivileges 2770 * 2771 * @param alphaTag The alpha tag to display. 2772 * @param number The voicemail number. 2773 */ setVoiceMailNumber(String alphaTag, String number)2774 public boolean setVoiceMailNumber(String alphaTag, String number) { 2775 return setVoiceMailNumber(getSubId(), alphaTag, number); 2776 } 2777 2778 /** 2779 * Sets the voicemail number for the given subscriber. 2780 * 2781 * <p>Requires that the calling app has carrier privileges. 2782 * @see #hasCarrierPrivileges 2783 * 2784 * @param subId The subscription id. 2785 * @param alphaTag The alpha tag to display. 2786 * @param number The voicemail number. 2787 * @hide 2788 */ setVoiceMailNumber(int subId, String alphaTag, String number)2789 public boolean setVoiceMailNumber(int subId, String alphaTag, String number) { 2790 try { 2791 ITelephony telephony = getITelephony(); 2792 if (telephony != null) 2793 return telephony.setVoiceMailNumber(subId, alphaTag, number); 2794 } catch (RemoteException ex) { 2795 } catch (NullPointerException ex) { 2796 } 2797 return false; 2798 } 2799 2800 /** 2801 * Enables or disables the visual voicemail client for a phone account. 2802 * 2803 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or 2804 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}. 2805 * @see #hasCarrierPrivileges 2806 * 2807 * @param phoneAccountHandle the phone account to change the client state 2808 * @param enabled the new state of the client 2809 * @hide 2810 * @deprecated Visual voicemail no longer in telephony. {@link VisualVoicemailService} should 2811 * be implemented instead. 2812 */ 2813 @SystemApi 2814 @SuppressLint("Doclava125") setVisualVoicemailEnabled(PhoneAccountHandle phoneAccountHandle, boolean enabled)2815 public void setVisualVoicemailEnabled(PhoneAccountHandle phoneAccountHandle, boolean enabled){ 2816 } 2817 2818 /** 2819 * Returns whether the visual voicemail client is enabled. 2820 * 2821 * @param phoneAccountHandle the phone account to check for. 2822 * @return {@code true} when the visual voicemail client is enabled for this client 2823 * @hide 2824 * @deprecated Visual voicemail no longer in telephony. {@link VisualVoicemailService} should 2825 * be implemented instead. 2826 */ 2827 @SystemApi 2828 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 2829 @SuppressLint("Doclava125") isVisualVoicemailEnabled(PhoneAccountHandle phoneAccountHandle)2830 public boolean isVisualVoicemailEnabled(PhoneAccountHandle phoneAccountHandle){ 2831 return false; 2832 } 2833 2834 /** 2835 * Returns an opaque bundle of settings formerly used by the visual voicemail client for the 2836 * subscription ID pinned to the TelephonyManager, or {@code null} if the subscription ID is 2837 * invalid. This method allows the system dialer to migrate settings out of the pre-O visual 2838 * voicemail client in telephony. 2839 * 2840 * <p>Requires the caller to be the system dialer. 2841 * 2842 * @see #KEY_VISUAL_VOICEMAIL_ENABLED_BY_USER_BOOL 2843 * @see #KEY_VOICEMAIL_SCRAMBLED_PIN_STRING 2844 * 2845 * @hide 2846 */ 2847 @SystemApi 2848 @SuppressLint("Doclava125") 2849 @Nullable getVisualVoicemailSettings()2850 public Bundle getVisualVoicemailSettings(){ 2851 try { 2852 ITelephony telephony = getITelephony(); 2853 if (telephony != null) { 2854 return telephony 2855 .getVisualVoicemailSettings(mContext.getOpPackageName(), mSubId); 2856 } 2857 } catch (RemoteException ex) { 2858 } catch (NullPointerException ex) { 2859 } 2860 return null; 2861 } 2862 2863 /** 2864 * Returns the package responsible of processing visual voicemail for the subscription ID pinned 2865 * to the TelephonyManager. Returns {@code null} when there is no package responsible for 2866 * processing visual voicemail for the subscription. 2867 * 2868 * @see #createForSubscriptionId(int) 2869 * @see #createForPhoneAccountHandle(PhoneAccountHandle) 2870 * @see VisualVoicemailService 2871 */ 2872 @Nullable 2873 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVisualVoicemailPackageName()2874 public String getVisualVoicemailPackageName() { 2875 try { 2876 ITelephony telephony = getITelephony(); 2877 if (telephony != null) { 2878 return telephony 2879 .getVisualVoicemailPackageName(mContext.getOpPackageName(), getSubId()); 2880 } 2881 } catch (RemoteException ex) { 2882 } catch (NullPointerException ex) { 2883 } 2884 return null; 2885 } 2886 2887 /** 2888 * Set the visual voicemail SMS filter settings for the subscription ID pinned 2889 * to the TelephonyManager. 2890 * When the filter is enabled, {@link 2891 * VisualVoicemailService#onSmsReceived(VisualVoicemailTask, VisualVoicemailSms)} will be 2892 * called when a SMS matching the settings is received. The caller should have 2893 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} and implement a 2894 * VisualVoicemailService. 2895 * 2896 * <p>Requires Permission: 2897 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 2898 * 2899 * @param settings The settings for the filter, or {@code null} to disable the filter. 2900 */ setVisualVoicemailSmsFilterSettings(VisualVoicemailSmsFilterSettings settings)2901 public void setVisualVoicemailSmsFilterSettings(VisualVoicemailSmsFilterSettings settings) { 2902 if (settings == null) { 2903 disableVisualVoicemailSmsFilter(mSubId); 2904 } else { 2905 enableVisualVoicemailSmsFilter(mSubId, settings); 2906 } 2907 } 2908 2909 /** 2910 * Send a visual voicemail SMS. The caller must be the current default dialer. 2911 * A {@link VisualVoicemailService} uses this method to send a command via SMS to the carrier's 2912 * visual voicemail server. Some examples for carriers using the OMTP standard include 2913 * activating and deactivating visual voicemail, or requesting the current visual voicemail 2914 * provisioning status. See the OMTP Visual Voicemail specification for more information on the 2915 * format of these SMS messages. 2916 * 2917 * <p>Requires Permission: 2918 * {@link android.Manifest.permission#SEND_SMS SEND_SMS} 2919 * 2920 * @param number The destination number. 2921 * @param port The destination port for data SMS, or 0 for text SMS. 2922 * @param text The message content. For data sms, it will be encoded as a UTF-8 byte stream. 2923 * @param sentIntent The sent intent passed to the {@link SmsManager} 2924 * 2925 * @throws SecurityException if the caller is not the current default dialer 2926 * 2927 * @see SmsManager#sendDataMessage(String, String, short, byte[], PendingIntent, PendingIntent) 2928 * @see SmsManager#sendTextMessage(String, String, String, PendingIntent, PendingIntent) 2929 */ sendVisualVoicemailSms(String number, int port, String text, PendingIntent sentIntent)2930 public void sendVisualVoicemailSms(String number, int port, String text, 2931 PendingIntent sentIntent) { 2932 sendVisualVoicemailSmsForSubscriber(mSubId, number, port, text, sentIntent); 2933 } 2934 2935 /** 2936 * Enables the visual voicemail SMS filter for a phone account. When the filter is 2937 * enabled, Incoming SMS messages matching the OMTP VVM SMS interface will be redirected to the 2938 * visual voicemail client with 2939 * {@link android.provider.VoicemailContract.ACTION_VOICEMAIL_SMS_RECEIVED}. 2940 * 2941 * <p>This takes effect only when the caller is the default dialer. The enabled status and 2942 * settings persist through default dialer changes, but the filter will only honor the setting 2943 * set by the current default dialer. 2944 * 2945 * 2946 * @param subId The subscription id of the phone account. 2947 * @param settings The settings for the filter. 2948 */ 2949 /** @hide */ enableVisualVoicemailSmsFilter(int subId, VisualVoicemailSmsFilterSettings settings)2950 public void enableVisualVoicemailSmsFilter(int subId, 2951 VisualVoicemailSmsFilterSettings settings) { 2952 if(settings == null){ 2953 throw new IllegalArgumentException("Settings cannot be null"); 2954 } 2955 try { 2956 ITelephony telephony = getITelephony(); 2957 if (telephony != null) { 2958 telephony.enableVisualVoicemailSmsFilter(mContext.getOpPackageName(), subId, 2959 settings); 2960 } 2961 } catch (RemoteException ex) { 2962 } catch (NullPointerException ex) { 2963 } 2964 } 2965 2966 /** 2967 * Disables the visual voicemail SMS filter for a phone account. 2968 * 2969 * <p>This takes effect only when the caller is the default dialer. The enabled status and 2970 * settings persist through default dialer changes, but the filter will only honor the setting 2971 * set by the current default dialer. 2972 */ 2973 /** @hide */ disableVisualVoicemailSmsFilter(int subId)2974 public void disableVisualVoicemailSmsFilter(int subId) { 2975 try { 2976 ITelephony telephony = getITelephony(); 2977 if (telephony != null) { 2978 telephony.disableVisualVoicemailSmsFilter(mContext.getOpPackageName(), subId); 2979 } 2980 } catch (RemoteException ex) { 2981 } catch (NullPointerException ex) { 2982 } 2983 } 2984 2985 /** 2986 * @returns the settings of the visual voicemail SMS filter for a phone account, or {@code null} 2987 * if the filter is disabled. 2988 * 2989 * <p>This takes effect only when the caller is the default dialer. The enabled status and 2990 * settings persist through default dialer changes, but the filter will only honor the setting 2991 * set by the current default dialer. 2992 */ 2993 /** @hide */ 2994 @Nullable getVisualVoicemailSmsFilterSettings(int subId)2995 public VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(int subId) { 2996 try { 2997 ITelephony telephony = getITelephony(); 2998 if (telephony != null) { 2999 return telephony 3000 .getVisualVoicemailSmsFilterSettings(mContext.getOpPackageName(), subId); 3001 } 3002 } catch (RemoteException ex) { 3003 } catch (NullPointerException ex) { 3004 } 3005 3006 return null; 3007 } 3008 3009 /** 3010 * @returns the settings of the visual voicemail SMS filter for a phone account set by the 3011 * current active visual voicemail client, or {@code null} if the filter is disabled. 3012 * 3013 * <p>Requires the calling app to have READ_PRIVILEGED_PHONE_STATE permission. 3014 */ 3015 /** @hide */ 3016 @Nullable getActiveVisualVoicemailSmsFilterSettings(int subId)3017 public VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId) { 3018 try { 3019 ITelephony telephony = getITelephony(); 3020 if (telephony != null) { 3021 return telephony.getActiveVisualVoicemailSmsFilterSettings(subId); 3022 } 3023 } catch (RemoteException ex) { 3024 } catch (NullPointerException ex) { 3025 } 3026 3027 return null; 3028 } 3029 3030 /** 3031 * Send a visual voicemail SMS. The IPC caller must be the current default dialer. 3032 * 3033 * @param phoneAccountHandle The account to send the SMS with. 3034 * @param number The destination number. 3035 * @param port The destination port for data SMS, or 0 for text SMS. 3036 * @param text The message content. For data sms, it will be encoded as a UTF-8 byte stream. 3037 * @param sentIntent The sent intent passed to the {@link SmsManager} 3038 * 3039 * @see SmsManager#sendDataMessage(String, String, short, byte[], PendingIntent, PendingIntent) 3040 * @see SmsManager#sendTextMessage(String, String, String, PendingIntent, PendingIntent) 3041 * 3042 * @hide 3043 */ 3044 @RequiresPermission(android.Manifest.permission.SEND_SMS) sendVisualVoicemailSmsForSubscriber(int subId, String number, int port, String text, PendingIntent sentIntent)3045 public void sendVisualVoicemailSmsForSubscriber(int subId, String number, int port, 3046 String text, PendingIntent sentIntent) { 3047 try { 3048 ITelephony telephony = getITelephony(); 3049 if (telephony != null) { 3050 telephony.sendVisualVoicemailSmsForSubscriber( 3051 mContext.getOpPackageName(), subId, number, port, text, sentIntent); 3052 } 3053 } catch (RemoteException ex) { 3054 } 3055 } 3056 3057 /** 3058 * Initial SIM activation state, unknown. Not set by any carrier apps. 3059 * @hide 3060 */ 3061 public static final int SIM_ACTIVATION_STATE_UNKNOWN = 0; 3062 3063 /** 3064 * indicate SIM is under activation procedure now. 3065 * intermediate state followed by another state update with activation procedure result: 3066 * @see #SIM_ACTIVATION_STATE_ACTIVATED 3067 * @see #SIM_ACTIVATION_STATE_DEACTIVATED 3068 * @see #SIM_ACTIVATION_STATE_RESTRICTED 3069 * @hide 3070 */ 3071 public static final int SIM_ACTIVATION_STATE_ACTIVATING = 1; 3072 3073 /** 3074 * Indicate SIM has been successfully activated with full service 3075 * @hide 3076 */ 3077 public static final int SIM_ACTIVATION_STATE_ACTIVATED = 2; 3078 3079 /** 3080 * Indicate SIM has been deactivated by the carrier so that service is not available 3081 * and requires activation service to enable services. 3082 * Carrier apps could be signalled to set activation state to deactivated if detected 3083 * deactivated sim state and set it back to activated after successfully run activation service. 3084 * @hide 3085 */ 3086 public static final int SIM_ACTIVATION_STATE_DEACTIVATED = 3; 3087 3088 /** 3089 * Restricted state indicate SIM has been activated but service are restricted. 3090 * note this is currently available for data activation state. For example out of byte sim. 3091 * @hide 3092 */ 3093 public static final int SIM_ACTIVATION_STATE_RESTRICTED = 4; 3094 3095 /** 3096 * Sets the voice activation state for the given subscriber. 3097 * 3098 * <p>Requires Permission: 3099 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3100 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3101 * 3102 * @param subId The subscription id. 3103 * @param activationState The voice activation state of the given subscriber. 3104 * @see #SIM_ACTIVATION_STATE_UNKNOWN 3105 * @see #SIM_ACTIVATION_STATE_ACTIVATING 3106 * @see #SIM_ACTIVATION_STATE_ACTIVATED 3107 * @see #SIM_ACTIVATION_STATE_DEACTIVATED 3108 * @hide 3109 */ setVoiceActivationState(int subId, int activationState)3110 public void setVoiceActivationState(int subId, int activationState) { 3111 try { 3112 ITelephony telephony = getITelephony(); 3113 if (telephony != null) 3114 telephony.setVoiceActivationState(subId, activationState); 3115 } catch (RemoteException ex) { 3116 } catch (NullPointerException ex) { 3117 } 3118 } 3119 3120 /** 3121 * Sets the data activation state for the given subscriber. 3122 * 3123 * <p>Requires Permission: 3124 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} 3125 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3126 * 3127 * @param subId The subscription id. 3128 * @param activationState The data activation state of the given subscriber. 3129 * @see #SIM_ACTIVATION_STATE_UNKNOWN 3130 * @see #SIM_ACTIVATION_STATE_ACTIVATING 3131 * @see #SIM_ACTIVATION_STATE_ACTIVATED 3132 * @see #SIM_ACTIVATION_STATE_DEACTIVATED 3133 * @see #SIM_ACTIVATION_STATE_RESTRICTED 3134 * @hide 3135 */ setDataActivationState(int subId, int activationState)3136 public void setDataActivationState(int subId, int activationState) { 3137 try { 3138 ITelephony telephony = getITelephony(); 3139 if (telephony != null) 3140 telephony.setDataActivationState(subId, activationState); 3141 } catch (RemoteException ex) { 3142 } catch (NullPointerException ex) { 3143 } 3144 } 3145 3146 /** 3147 * Returns the voice activation state for the given subscriber. 3148 * 3149 * @param subId The subscription id. 3150 * 3151 * @return voiceActivationState for the given subscriber 3152 * @see #SIM_ACTIVATION_STATE_UNKNOWN 3153 * @see #SIM_ACTIVATION_STATE_ACTIVATING 3154 * @see #SIM_ACTIVATION_STATE_ACTIVATED 3155 * @see #SIM_ACTIVATION_STATE_DEACTIVATED 3156 * @hide 3157 */ 3158 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceActivationState(int subId)3159 public int getVoiceActivationState(int subId) { 3160 try { 3161 ITelephony telephony = getITelephony(); 3162 if (telephony != null) 3163 return telephony.getVoiceActivationState(subId, getOpPackageName()); 3164 } catch (RemoteException ex) { 3165 } catch (NullPointerException ex) { 3166 } 3167 return SIM_ACTIVATION_STATE_UNKNOWN; 3168 } 3169 3170 /** 3171 * Returns the data activation state for the given subscriber. 3172 * 3173 * @param subId The subscription id. 3174 * 3175 * @return dataActivationState for the given subscriber 3176 * @see #SIM_ACTIVATION_STATE_UNKNOWN 3177 * @see #SIM_ACTIVATION_STATE_ACTIVATING 3178 * @see #SIM_ACTIVATION_STATE_ACTIVATED 3179 * @see #SIM_ACTIVATION_STATE_DEACTIVATED 3180 * @see #SIM_ACTIVATION_STATE_RESTRICTED 3181 * @hide 3182 */ 3183 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDataActivationState(int subId)3184 public int getDataActivationState(int subId) { 3185 try { 3186 ITelephony telephony = getITelephony(); 3187 if (telephony != null) 3188 return telephony.getDataActivationState(subId, getOpPackageName()); 3189 } catch (RemoteException ex) { 3190 } catch (NullPointerException ex) { 3191 } 3192 return SIM_ACTIVATION_STATE_UNKNOWN; 3193 } 3194 3195 /** 3196 * Returns the voice mail count. Return 0 if unavailable, -1 if there are unread voice messages 3197 * but the count is unknown. 3198 * @hide 3199 */ 3200 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMessageCount()3201 public int getVoiceMessageCount() { 3202 return getVoiceMessageCount(getSubId()); 3203 } 3204 3205 /** 3206 * Returns the voice mail count for a subscription. Return 0 if unavailable. 3207 * @param subId whose voice message count is returned 3208 * @hide 3209 */ 3210 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMessageCount(int subId)3211 public int getVoiceMessageCount(int subId) { 3212 try { 3213 ITelephony telephony = getITelephony(); 3214 if (telephony == null) 3215 return 0; 3216 return telephony.getVoiceMessageCountForSubscriber(subId); 3217 } catch (RemoteException ex) { 3218 return 0; 3219 } catch (NullPointerException ex) { 3220 // This could happen before phone restarts due to crashing 3221 return 0; 3222 } 3223 } 3224 3225 /** 3226 * Retrieves the alphabetic identifier associated with the voice 3227 * mail number. 3228 */ 3229 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMailAlphaTag()3230 public String getVoiceMailAlphaTag() { 3231 return getVoiceMailAlphaTag(getSubId()); 3232 } 3233 3234 /** 3235 * Retrieves the alphabetic identifier associated with the voice 3236 * mail number for a subscription. 3237 * @param subId whose alphabetic identifier associated with the 3238 * voice mail number is returned 3239 * @hide 3240 */ 3241 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMailAlphaTag(int subId)3242 public String getVoiceMailAlphaTag(int subId) { 3243 try { 3244 IPhoneSubInfo info = getSubscriberInfo(); 3245 if (info == null) 3246 return null; 3247 return info.getVoiceMailAlphaTagForSubscriber(subId, getOpPackageName()); 3248 } catch (RemoteException ex) { 3249 return null; 3250 } catch (NullPointerException ex) { 3251 // This could happen before phone restarts due to crashing 3252 return null; 3253 } 3254 } 3255 3256 /** 3257 * Send the special dialer code. The IPC caller must be the current default dialer or has 3258 * carrier privileges. 3259 * @see #hasCarrierPrivileges 3260 * 3261 * @param inputCode The special dialer code to send 3262 * 3263 * @throws SecurityException if the caller does not have carrier privileges or is not the 3264 * current default dialer 3265 * 3266 * @throws IllegalStateException if telephony service is unavailable. 3267 */ sendDialerSpecialCode(String inputCode)3268 public void sendDialerSpecialCode(String inputCode) { 3269 try { 3270 final ITelephony telephony = getITelephony(); 3271 telephony.sendDialerSpecialCode(mContext.getOpPackageName(), inputCode); 3272 } catch (RemoteException ex) { 3273 // This could happen if binder process crashes. 3274 ex.rethrowFromSystemServer(); 3275 } catch (NullPointerException ex) { 3276 // This could happen before phone restarts due to crashing 3277 throw new IllegalStateException("Telephony service unavailable"); 3278 } 3279 } 3280 3281 /** 3282 * Returns the IMS private user identity (IMPI) that was loaded from the ISIM. 3283 * @return the IMPI, or null if not present or not loaded 3284 * @hide 3285 */ getIsimImpi()3286 public String getIsimImpi() { 3287 try { 3288 IPhoneSubInfo info = getSubscriberInfo(); 3289 if (info == null) 3290 return null; 3291 return info.getIsimImpi(); 3292 } catch (RemoteException ex) { 3293 return null; 3294 } catch (NullPointerException ex) { 3295 // This could happen before phone restarts due to crashing 3296 return null; 3297 } 3298 } 3299 3300 /** 3301 * Returns the IMS home network domain name that was loaded from the ISIM. 3302 * @return the IMS domain name, or null if not present or not loaded 3303 * @hide 3304 */ getIsimDomain()3305 public String getIsimDomain() { 3306 try { 3307 IPhoneSubInfo info = getSubscriberInfo(); 3308 if (info == null) 3309 return null; 3310 return info.getIsimDomain(); 3311 } catch (RemoteException ex) { 3312 return null; 3313 } catch (NullPointerException ex) { 3314 // This could happen before phone restarts due to crashing 3315 return null; 3316 } 3317 } 3318 3319 /** 3320 * Returns the IMS public user identities (IMPU) that were loaded from the ISIM. 3321 * @return an array of IMPU strings, with one IMPU per string, or null if 3322 * not present or not loaded 3323 * @hide 3324 */ getIsimImpu()3325 public String[] getIsimImpu() { 3326 try { 3327 IPhoneSubInfo info = getSubscriberInfo(); 3328 if (info == null) 3329 return null; 3330 return info.getIsimImpu(); 3331 } catch (RemoteException ex) { 3332 return null; 3333 } catch (NullPointerException ex) { 3334 // This could happen before phone restarts due to crashing 3335 return null; 3336 } 3337 } 3338 3339 /** 3340 * @hide 3341 */ getSubscriberInfo()3342 private IPhoneSubInfo getSubscriberInfo() { 3343 // get it each time because that process crashes a lot 3344 return IPhoneSubInfo.Stub.asInterface(ServiceManager.getService("iphonesubinfo")); 3345 } 3346 3347 /** Device call state: No activity. */ 3348 public static final int CALL_STATE_IDLE = 0; 3349 /** Device call state: Ringing. A new call arrived and is 3350 * ringing or waiting. In the latter case, another call is 3351 * already active. */ 3352 public static final int CALL_STATE_RINGING = 1; 3353 /** Device call state: Off-hook. At least one call exists 3354 * that is dialing, active, or on hold, and no calls are ringing 3355 * or waiting. */ 3356 public static final int CALL_STATE_OFFHOOK = 2; 3357 3358 /** 3359 * Returns one of the following constants that represents the current state of all 3360 * phone calls. 3361 * 3362 * {@link TelephonyManager#CALL_STATE_RINGING} 3363 * {@link TelephonyManager#CALL_STATE_OFFHOOK} 3364 * {@link TelephonyManager#CALL_STATE_IDLE} 3365 */ getCallState()3366 public int getCallState() { 3367 try { 3368 ITelecomService telecom = getTelecomService(); 3369 if (telecom != null) { 3370 return telecom.getCallState(); 3371 } 3372 } catch (RemoteException e) { 3373 Log.e(TAG, "Error calling ITelecomService#getCallState", e); 3374 } 3375 return CALL_STATE_IDLE; 3376 } 3377 3378 /** 3379 * Returns a constant indicating the call state (cellular) on the device 3380 * for a subscription. 3381 * 3382 * @param subId whose call state is returned 3383 * @hide 3384 */ getCallState(int subId)3385 public int getCallState(int subId) { 3386 int phoneId = SubscriptionManager.getPhoneId(subId); 3387 return getCallStateForSlot(phoneId); 3388 } 3389 3390 /** 3391 * See getCallState. 3392 * 3393 * @hide 3394 */ getCallStateForSlot(int slotIndex)3395 public int getCallStateForSlot(int slotIndex) { 3396 try { 3397 ITelephony telephony = getITelephony(); 3398 if (telephony == null) 3399 return CALL_STATE_IDLE; 3400 return telephony.getCallStateForSlot(slotIndex); 3401 } catch (RemoteException ex) { 3402 // the phone process is restarting. 3403 return CALL_STATE_IDLE; 3404 } catch (NullPointerException ex) { 3405 // the phone process is restarting. 3406 return CALL_STATE_IDLE; 3407 } 3408 } 3409 3410 3411 /** Data connection activity: No traffic. */ 3412 public static final int DATA_ACTIVITY_NONE = 0x00000000; 3413 /** Data connection activity: Currently receiving IP PPP traffic. */ 3414 public static final int DATA_ACTIVITY_IN = 0x00000001; 3415 /** Data connection activity: Currently sending IP PPP traffic. */ 3416 public static final int DATA_ACTIVITY_OUT = 0x00000002; 3417 /** Data connection activity: Currently both sending and receiving 3418 * IP PPP traffic. */ 3419 public static final int DATA_ACTIVITY_INOUT = DATA_ACTIVITY_IN | DATA_ACTIVITY_OUT; 3420 /** 3421 * Data connection is active, but physical link is down 3422 */ 3423 public static final int DATA_ACTIVITY_DORMANT = 0x00000004; 3424 3425 /** 3426 * Returns a constant indicating the type of activity on a data connection 3427 * (cellular). 3428 * 3429 * @see #DATA_ACTIVITY_NONE 3430 * @see #DATA_ACTIVITY_IN 3431 * @see #DATA_ACTIVITY_OUT 3432 * @see #DATA_ACTIVITY_INOUT 3433 * @see #DATA_ACTIVITY_DORMANT 3434 */ getDataActivity()3435 public int getDataActivity() { 3436 try { 3437 ITelephony telephony = getITelephony(); 3438 if (telephony == null) 3439 return DATA_ACTIVITY_NONE; 3440 return telephony.getDataActivity(); 3441 } catch (RemoteException ex) { 3442 // the phone process is restarting. 3443 return DATA_ACTIVITY_NONE; 3444 } catch (NullPointerException ex) { 3445 // the phone process is restarting. 3446 return DATA_ACTIVITY_NONE; 3447 } 3448 } 3449 3450 /** Data connection state: Unknown. Used before we know the state. 3451 * @hide 3452 */ 3453 public static final int DATA_UNKNOWN = -1; 3454 /** Data connection state: Disconnected. IP traffic not available. */ 3455 public static final int DATA_DISCONNECTED = 0; 3456 /** Data connection state: Currently setting up a data connection. */ 3457 public static final int DATA_CONNECTING = 1; 3458 /** Data connection state: Connected. IP traffic should be available. */ 3459 public static final int DATA_CONNECTED = 2; 3460 /** Data connection state: Suspended. The connection is up, but IP 3461 * traffic is temporarily unavailable. For example, in a 2G network, 3462 * data activity may be suspended when a voice call arrives. */ 3463 public static final int DATA_SUSPENDED = 3; 3464 3465 /** 3466 * Returns a constant indicating the current data connection state 3467 * (cellular). 3468 * 3469 * @see #DATA_DISCONNECTED 3470 * @see #DATA_CONNECTING 3471 * @see #DATA_CONNECTED 3472 * @see #DATA_SUSPENDED 3473 */ getDataState()3474 public int getDataState() { 3475 try { 3476 ITelephony telephony = getITelephony(); 3477 if (telephony == null) 3478 return DATA_DISCONNECTED; 3479 return telephony.getDataState(); 3480 } catch (RemoteException ex) { 3481 // the phone process is restarting. 3482 return DATA_DISCONNECTED; 3483 } catch (NullPointerException ex) { 3484 return DATA_DISCONNECTED; 3485 } 3486 } 3487 3488 /** 3489 * @hide 3490 */ getITelephony()3491 private ITelephony getITelephony() { 3492 return ITelephony.Stub.asInterface(ServiceManager.getService(Context.TELEPHONY_SERVICE)); 3493 } 3494 3495 /** 3496 * @hide 3497 */ getTelecomService()3498 private ITelecomService getTelecomService() { 3499 return ITelecomService.Stub.asInterface(ServiceManager.getService(Context.TELECOM_SERVICE)); 3500 } 3501 getTelephonyRegistry()3502 private ITelephonyRegistry getTelephonyRegistry() { 3503 return ITelephonyRegistry.Stub.asInterface(ServiceManager.getService("telephony.registry")); 3504 } 3505 3506 // 3507 // 3508 // PhoneStateListener 3509 // 3510 // 3511 3512 /** 3513 * Registers a listener object to receive notification of changes 3514 * in specified telephony states. 3515 * <p> 3516 * To register a listener, pass a {@link PhoneStateListener} 3517 * and specify at least one telephony state of interest in 3518 * the events argument. 3519 * 3520 * At registration, and when a specified telephony state 3521 * changes, the telephony manager invokes the appropriate 3522 * callback method on the listener object and passes the 3523 * current (updated) values. 3524 * <p> 3525 * To unregister a listener, pass the listener object and set the 3526 * events argument to 3527 * {@link PhoneStateListener#LISTEN_NONE LISTEN_NONE} (0). 3528 * 3529 * @param listener The {@link PhoneStateListener} object to register 3530 * (or unregister) 3531 * @param events The telephony state(s) of interest to the listener, 3532 * as a bitwise-OR combination of {@link PhoneStateListener} 3533 * LISTEN_ flags. 3534 */ listen(PhoneStateListener listener, int events)3535 public void listen(PhoneStateListener listener, int events) { 3536 if (mContext == null) return; 3537 try { 3538 boolean notifyNow = (getITelephony() != null); 3539 // If the listener has not explicitly set the subId (for example, created with the 3540 // default constructor), replace the subId so it will listen to the account the 3541 // telephony manager is created with. 3542 if (listener.mSubId == null) { 3543 listener.mSubId = mSubId; 3544 } 3545 3546 ITelephonyRegistry registry = getTelephonyRegistry(); 3547 if (registry != null) { 3548 registry.listenForSubscriber(listener.mSubId, getOpPackageName(), 3549 listener.callback, events, notifyNow); 3550 } else { 3551 Rlog.w(TAG, "telephony registry not ready."); 3552 } 3553 } catch (RemoteException ex) { 3554 // system process dead 3555 } 3556 } 3557 3558 /** 3559 * Returns the CDMA ERI icon index to display 3560 * @hide 3561 */ 3562 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriIconIndex()3563 public int getCdmaEriIconIndex() { 3564 return getCdmaEriIconIndex(getSubId()); 3565 } 3566 3567 /** 3568 * Returns the CDMA ERI icon index to display for a subscription 3569 * @hide 3570 */ 3571 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriIconIndex(int subId)3572 public int getCdmaEriIconIndex(int subId) { 3573 try { 3574 ITelephony telephony = getITelephony(); 3575 if (telephony == null) 3576 return -1; 3577 return telephony.getCdmaEriIconIndexForSubscriber(subId, getOpPackageName()); 3578 } catch (RemoteException ex) { 3579 // the phone process is restarting. 3580 return -1; 3581 } catch (NullPointerException ex) { 3582 return -1; 3583 } 3584 } 3585 3586 /** 3587 * Returns the CDMA ERI icon mode, 3588 * 0 - ON 3589 * 1 - FLASHING 3590 * 3591 * @hide 3592 */ 3593 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriIconMode()3594 public int getCdmaEriIconMode() { 3595 return getCdmaEriIconMode(getSubId()); 3596 } 3597 3598 /** 3599 * Returns the CDMA ERI icon mode for a subscription. 3600 * 0 - ON 3601 * 1 - FLASHING 3602 * 3603 * @hide 3604 */ 3605 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriIconMode(int subId)3606 public int getCdmaEriIconMode(int subId) { 3607 try { 3608 ITelephony telephony = getITelephony(); 3609 if (telephony == null) 3610 return -1; 3611 return telephony.getCdmaEriIconModeForSubscriber(subId, getOpPackageName()); 3612 } catch (RemoteException ex) { 3613 // the phone process is restarting. 3614 return -1; 3615 } catch (NullPointerException ex) { 3616 return -1; 3617 } 3618 } 3619 3620 /** 3621 * Returns the CDMA ERI text, 3622 * 3623 * @hide 3624 */ 3625 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriText()3626 public String getCdmaEriText() { 3627 return getCdmaEriText(getSubId()); 3628 } 3629 3630 /** 3631 * Returns the CDMA ERI text, of a subscription 3632 * 3633 * @hide 3634 */ 3635 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCdmaEriText(int subId)3636 public String getCdmaEriText(int subId) { 3637 try { 3638 ITelephony telephony = getITelephony(); 3639 if (telephony == null) 3640 return null; 3641 return telephony.getCdmaEriTextForSubscriber(subId, getOpPackageName()); 3642 } catch (RemoteException ex) { 3643 // the phone process is restarting. 3644 return null; 3645 } catch (NullPointerException ex) { 3646 return null; 3647 } 3648 } 3649 3650 /** 3651 * @return true if the current device is "voice capable". 3652 * <p> 3653 * "Voice capable" means that this device supports circuit-switched 3654 * (i.e. voice) phone calls over the telephony network, and is allowed 3655 * to display the in-call UI while a cellular voice call is active. 3656 * This will be false on "data only" devices which can't make voice 3657 * calls and don't support any in-call UI. 3658 * <p> 3659 * Note: the meaning of this flag is subtly different from the 3660 * PackageManager.FEATURE_TELEPHONY system feature, which is available 3661 * on any device with a telephony radio, even if the device is 3662 * data-only. 3663 */ isVoiceCapable()3664 public boolean isVoiceCapable() { 3665 if (mContext == null) return true; 3666 return mContext.getResources().getBoolean( 3667 com.android.internal.R.bool.config_voice_capable); 3668 } 3669 3670 /** 3671 * @return true if the current device supports sms service. 3672 * <p> 3673 * If true, this means that the device supports both sending and 3674 * receiving sms via the telephony network. 3675 * <p> 3676 * Note: Voicemail waiting sms, cell broadcasting sms, and MMS are 3677 * disabled when device doesn't support sms. 3678 */ isSmsCapable()3679 public boolean isSmsCapable() { 3680 if (mContext == null) return true; 3681 return mContext.getResources().getBoolean( 3682 com.android.internal.R.bool.config_sms_capable); 3683 } 3684 3685 /** 3686 * Returns all observed cell information from all radios on the 3687 * device including the primary and neighboring cells. Calling this method does 3688 * not trigger a call to {@link android.telephony.PhoneStateListener#onCellInfoChanged 3689 * onCellInfoChanged()}, or change the rate at which 3690 * {@link android.telephony.PhoneStateListener#onCellInfoChanged 3691 * onCellInfoChanged()} is called. 3692 * 3693 *<p> 3694 * The list can include one or more {@link android.telephony.CellInfoGsm CellInfoGsm}, 3695 * {@link android.telephony.CellInfoCdma CellInfoCdma}, 3696 * {@link android.telephony.CellInfoLte CellInfoLte}, and 3697 * {@link android.telephony.CellInfoWcdma CellInfoWcdma} objects, in any combination. 3698 * On devices with multiple radios it is typical to see instances of 3699 * one or more of any these in the list. In addition, zero, one, or more 3700 * of the returned objects may be considered registered; that is, their 3701 * {@link android.telephony.CellInfo#isRegistered CellInfo.isRegistered()} 3702 * methods may return true. 3703 * 3704 * <p>This method returns valid data for registered cells on devices with 3705 * {@link android.content.pm.PackageManager#FEATURE_TELEPHONY}. In cases where only 3706 * partial information is available for a particular CellInfo entry, unavailable fields 3707 * will be reported as Integer.MAX_VALUE. All reported cells will include at least a 3708 * valid set of technology-specific identification info and a power level measurement. 3709 * 3710 *<p> 3711 * This method is preferred over using {@link 3712 * android.telephony.TelephonyManager#getCellLocation getCellLocation()}. 3713 * However, for older devices, <code>getAllCellInfo()</code> may return 3714 * null. In these cases, you should call {@link 3715 * android.telephony.TelephonyManager#getCellLocation getCellLocation()} 3716 * instead. 3717 * 3718 * @return List of {@link android.telephony.CellInfo}; null if cell 3719 * information is unavailable. 3720 */ 3721 @RequiresPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION) getAllCellInfo()3722 public List<CellInfo> getAllCellInfo() { 3723 try { 3724 ITelephony telephony = getITelephony(); 3725 if (telephony == null) 3726 return null; 3727 return telephony.getAllCellInfo(getOpPackageName()); 3728 } catch (RemoteException ex) { 3729 return null; 3730 } catch (NullPointerException ex) { 3731 return null; 3732 } 3733 } 3734 3735 /** 3736 * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged 3737 * PhoneStateListener.onCellInfoChanged} will be invoked. 3738 *<p> 3739 * The default, 0, means invoke onCellInfoChanged when any of the reported 3740 * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue 3741 * A onCellInfoChanged. 3742 *<p> 3743 * @param rateInMillis the rate 3744 * 3745 * @hide 3746 */ setCellInfoListRate(int rateInMillis)3747 public void setCellInfoListRate(int rateInMillis) { 3748 try { 3749 ITelephony telephony = getITelephony(); 3750 if (telephony != null) 3751 telephony.setCellInfoListRate(rateInMillis); 3752 } catch (RemoteException ex) { 3753 } catch (NullPointerException ex) { 3754 } 3755 } 3756 3757 /** 3758 * Returns the MMS user agent. 3759 */ getMmsUserAgent()3760 public String getMmsUserAgent() { 3761 if (mContext == null) return null; 3762 return mContext.getResources().getString( 3763 com.android.internal.R.string.config_mms_user_agent); 3764 } 3765 3766 /** 3767 * Returns the MMS user agent profile URL. 3768 */ getMmsUAProfUrl()3769 public String getMmsUAProfUrl() { 3770 if (mContext == null) return null; 3771 return mContext.getResources().getString( 3772 com.android.internal.R.string.config_mms_user_agent_profile_url); 3773 } 3774 3775 /** 3776 * Opens a logical channel to the ICC card. 3777 * 3778 * Input parameters equivalent to TS 27.007 AT+CCHO command. 3779 * 3780 * <p>Requires Permission: 3781 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3782 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3783 * 3784 * @param AID Application id. See ETSI 102.221 and 101.220. 3785 * @return an IccOpenLogicalChannelResponse object. 3786 * @deprecated Replaced by {@link #iccOpenLogicalChannel(String, int)} 3787 */ 3788 @Deprecated iccOpenLogicalChannel(String AID)3789 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(String AID) { 3790 return iccOpenLogicalChannel(getSubId(), AID, -1); 3791 } 3792 3793 /** 3794 * Opens a logical channel to the ICC card. 3795 * 3796 * Input parameters equivalent to TS 27.007 AT+CCHO command. 3797 * 3798 * <p>Requires Permission: 3799 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3800 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3801 * 3802 * @param AID Application id. See ETSI 102.221 and 101.220. 3803 * @param p2 P2 parameter (described in ISO 7816-4). 3804 * @return an IccOpenLogicalChannelResponse object. 3805 */ iccOpenLogicalChannel(String AID, int p2)3806 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(String AID, int p2) { 3807 return iccOpenLogicalChannel(getSubId(), AID, p2); 3808 } 3809 3810 /** 3811 * Opens a logical channel to the ICC card. 3812 * 3813 * Input parameters equivalent to TS 27.007 AT+CCHO command. 3814 * 3815 * <p>Requires Permission: 3816 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3817 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3818 * 3819 * @param subId The subscription to use. 3820 * @param AID Application id. See ETSI 102.221 and 101.220. 3821 * @param p2 P2 parameter (described in ISO 7816-4). 3822 * @return an IccOpenLogicalChannelResponse object. 3823 * @hide 3824 */ iccOpenLogicalChannel(int subId, String AID, int p2)3825 public IccOpenLogicalChannelResponse iccOpenLogicalChannel(int subId, String AID, int p2) { 3826 try { 3827 ITelephony telephony = getITelephony(); 3828 if (telephony != null) 3829 return telephony.iccOpenLogicalChannel(subId, getOpPackageName(), AID, p2); 3830 } catch (RemoteException ex) { 3831 } catch (NullPointerException ex) { 3832 } 3833 return null; 3834 } 3835 3836 /** 3837 * Closes a previously opened logical channel to the ICC card. 3838 * 3839 * Input parameters equivalent to TS 27.007 AT+CCHC command. 3840 * 3841 * <p>Requires Permission: 3842 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3843 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3844 * 3845 * @param channel is the channel id to be closed as retruned by a successful 3846 * iccOpenLogicalChannel. 3847 * @return true if the channel was closed successfully. 3848 */ iccCloseLogicalChannel(int channel)3849 public boolean iccCloseLogicalChannel(int channel) { 3850 return iccCloseLogicalChannel(getSubId(), channel); 3851 } 3852 3853 /** 3854 * Closes a previously opened logical channel to the ICC card. 3855 * 3856 * Input parameters equivalent to TS 27.007 AT+CCHC command. 3857 * 3858 * <p>Requires Permission: 3859 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3860 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3861 * 3862 * @param subId The subscription to use. 3863 * @param channel is the channel id to be closed as retruned by a successful 3864 * iccOpenLogicalChannel. 3865 * @return true if the channel was closed successfully. 3866 * @hide 3867 */ iccCloseLogicalChannel(int subId, int channel)3868 public boolean iccCloseLogicalChannel(int subId, int channel) { 3869 try { 3870 ITelephony telephony = getITelephony(); 3871 if (telephony != null) 3872 return telephony.iccCloseLogicalChannel(subId, channel); 3873 } catch (RemoteException ex) { 3874 } catch (NullPointerException ex) { 3875 } 3876 return false; 3877 } 3878 3879 /** 3880 * Transmit an APDU to the ICC card over a logical channel. 3881 * 3882 * Input parameters equivalent to TS 27.007 AT+CGLA command. 3883 * 3884 * <p>Requires Permission: 3885 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3886 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3887 * 3888 * @param channel is the channel id to be closed as returned by a successful 3889 * iccOpenLogicalChannel. 3890 * @param cla Class of the APDU command. 3891 * @param instruction Instruction of the APDU command. 3892 * @param p1 P1 value of the APDU command. 3893 * @param p2 P2 value of the APDU command. 3894 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 3895 * is sent to the SIM. 3896 * @param data Data to be sent with the APDU. 3897 * @return The APDU response from the ICC card with the status appended at 3898 * the end. 3899 */ iccTransmitApduLogicalChannel(int channel, int cla, int instruction, int p1, int p2, int p3, String data)3900 public String iccTransmitApduLogicalChannel(int channel, int cla, 3901 int instruction, int p1, int p2, int p3, String data) { 3902 return iccTransmitApduLogicalChannel(getSubId(), channel, cla, 3903 instruction, p1, p2, p3, data); 3904 } 3905 3906 /** 3907 * Transmit an APDU to the ICC card over a logical channel. 3908 * 3909 * Input parameters equivalent to TS 27.007 AT+CGLA command. 3910 * 3911 * <p>Requires Permission: 3912 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3913 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3914 * 3915 * @param subId The subscription to use. 3916 * @param channel is the channel id to be closed as returned by a successful 3917 * iccOpenLogicalChannel. 3918 * @param cla Class of the APDU command. 3919 * @param instruction Instruction of the APDU command. 3920 * @param p1 P1 value of the APDU command. 3921 * @param p2 P2 value of the APDU command. 3922 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 3923 * is sent to the SIM. 3924 * @param data Data to be sent with the APDU. 3925 * @return The APDU response from the ICC card with the status appended at 3926 * the end. 3927 * @hide 3928 */ iccTransmitApduLogicalChannel(int subId, int channel, int cla, int instruction, int p1, int p2, int p3, String data)3929 public String iccTransmitApduLogicalChannel(int subId, int channel, int cla, 3930 int instruction, int p1, int p2, int p3, String data) { 3931 try { 3932 ITelephony telephony = getITelephony(); 3933 if (telephony != null) 3934 return telephony.iccTransmitApduLogicalChannel(subId, channel, cla, 3935 instruction, p1, p2, p3, data); 3936 } catch (RemoteException ex) { 3937 } catch (NullPointerException ex) { 3938 } 3939 return ""; 3940 } 3941 3942 /** 3943 * Transmit an APDU to the ICC card over the basic channel. 3944 * 3945 * Input parameters equivalent to TS 27.007 AT+CSIM command. 3946 * 3947 * <p>Requires Permission: 3948 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3949 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3950 * 3951 * @param cla Class of the APDU command. 3952 * @param instruction Instruction of the APDU command. 3953 * @param p1 P1 value of the APDU command. 3954 * @param p2 P2 value of the APDU command. 3955 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 3956 * is sent to the SIM. 3957 * @param data Data to be sent with the APDU. 3958 * @return The APDU response from the ICC card with the status appended at 3959 * the end. 3960 */ iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2, int p3, String data)3961 public String iccTransmitApduBasicChannel(int cla, 3962 int instruction, int p1, int p2, int p3, String data) { 3963 return iccTransmitApduBasicChannel(getSubId(), cla, 3964 instruction, p1, p2, p3, data); 3965 } 3966 3967 /** 3968 * Transmit an APDU to the ICC card over the basic channel. 3969 * 3970 * Input parameters equivalent to TS 27.007 AT+CSIM command. 3971 * 3972 * <p>Requires Permission: 3973 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 3974 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 3975 * 3976 * @param subId The subscription to use. 3977 * @param cla Class of the APDU command. 3978 * @param instruction Instruction of the APDU command. 3979 * @param p1 P1 value of the APDU command. 3980 * @param p2 P2 value of the APDU command. 3981 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 3982 * is sent to the SIM. 3983 * @param data Data to be sent with the APDU. 3984 * @return The APDU response from the ICC card with the status appended at 3985 * the end. 3986 * @hide 3987 */ iccTransmitApduBasicChannel(int subId, int cla, int instruction, int p1, int p2, int p3, String data)3988 public String iccTransmitApduBasicChannel(int subId, int cla, 3989 int instruction, int p1, int p2, int p3, String data) { 3990 try { 3991 ITelephony telephony = getITelephony(); 3992 if (telephony != null) 3993 return telephony.iccTransmitApduBasicChannel(subId, cla, 3994 instruction, p1, p2, p3, data); 3995 } catch (RemoteException ex) { 3996 } catch (NullPointerException ex) { 3997 } 3998 return ""; 3999 } 4000 4001 /** 4002 * Returns the response APDU for a command APDU sent through SIM_IO. 4003 * 4004 * <p>Requires Permission: 4005 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4006 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4007 * 4008 * @param fileID 4009 * @param command 4010 * @param p1 P1 value of the APDU command. 4011 * @param p2 P2 value of the APDU command. 4012 * @param p3 P3 value of the APDU command. 4013 * @param filePath 4014 * @return The APDU response. 4015 */ iccExchangeSimIO(int fileID, int command, int p1, int p2, int p3, String filePath)4016 public byte[] iccExchangeSimIO(int fileID, int command, int p1, int p2, int p3, 4017 String filePath) { 4018 return iccExchangeSimIO(getSubId(), fileID, command, p1, p2, p3, filePath); 4019 } 4020 4021 /** 4022 * Returns the response APDU for a command APDU sent through SIM_IO. 4023 * 4024 * <p>Requires Permission: 4025 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4026 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4027 * 4028 * @param subId The subscription to use. 4029 * @param fileID 4030 * @param command 4031 * @param p1 P1 value of the APDU command. 4032 * @param p2 P2 value of the APDU command. 4033 * @param p3 P3 value of the APDU command. 4034 * @param filePath 4035 * @return The APDU response. 4036 * @hide 4037 */ iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3, String filePath)4038 public byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, 4039 int p3, String filePath) { 4040 try { 4041 ITelephony telephony = getITelephony(); 4042 if (telephony != null) 4043 return telephony.iccExchangeSimIO(subId, fileID, command, p1, p2, p3, filePath); 4044 } catch (RemoteException ex) { 4045 } catch (NullPointerException ex) { 4046 } 4047 return null; 4048 } 4049 4050 /** 4051 * Send ENVELOPE to the SIM and return the response. 4052 * 4053 * <p>Requires Permission: 4054 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4055 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4056 * 4057 * @param content String containing SAT/USAT response in hexadecimal 4058 * format starting with command tag. See TS 102 223 for 4059 * details. 4060 * @return The APDU response from the ICC card in hexadecimal format 4061 * with the last 4 bytes being the status word. If the command fails, 4062 * returns an empty string. 4063 */ sendEnvelopeWithStatus(String content)4064 public String sendEnvelopeWithStatus(String content) { 4065 return sendEnvelopeWithStatus(getSubId(), content); 4066 } 4067 4068 /** 4069 * Send ENVELOPE to the SIM and return the response. 4070 * 4071 * <p>Requires Permission: 4072 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4073 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4074 * 4075 * @param subId The subscription to use. 4076 * @param content String containing SAT/USAT response in hexadecimal 4077 * format starting with command tag. See TS 102 223 for 4078 * details. 4079 * @return The APDU response from the ICC card in hexadecimal format 4080 * with the last 4 bytes being the status word. If the command fails, 4081 * returns an empty string. 4082 * @hide 4083 */ sendEnvelopeWithStatus(int subId, String content)4084 public String sendEnvelopeWithStatus(int subId, String content) { 4085 try { 4086 ITelephony telephony = getITelephony(); 4087 if (telephony != null) 4088 return telephony.sendEnvelopeWithStatus(subId, content); 4089 } catch (RemoteException ex) { 4090 } catch (NullPointerException ex) { 4091 } 4092 return ""; 4093 } 4094 4095 /** 4096 * Read one of the NV items defined in com.android.internal.telephony.RadioNVItems. 4097 * Used for device configuration by some CDMA operators. 4098 * <p> 4099 * Requires Permission: 4100 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4101 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4102 * 4103 * @param itemID the ID of the item to read. 4104 * @return the NV item as a String, or null on any failure. 4105 * 4106 * @hide 4107 */ nvReadItem(int itemID)4108 public String nvReadItem(int itemID) { 4109 try { 4110 ITelephony telephony = getITelephony(); 4111 if (telephony != null) 4112 return telephony.nvReadItem(itemID); 4113 } catch (RemoteException ex) { 4114 Rlog.e(TAG, "nvReadItem RemoteException", ex); 4115 } catch (NullPointerException ex) { 4116 Rlog.e(TAG, "nvReadItem NPE", ex); 4117 } 4118 return ""; 4119 } 4120 4121 /** 4122 * Write one of the NV items defined in com.android.internal.telephony.RadioNVItems. 4123 * Used for device configuration by some CDMA operators. 4124 * <p> 4125 * Requires Permission: 4126 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4127 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4128 * 4129 * @param itemID the ID of the item to read. 4130 * @param itemValue the value to write, as a String. 4131 * @return true on success; false on any failure. 4132 * 4133 * @hide 4134 */ nvWriteItem(int itemID, String itemValue)4135 public boolean nvWriteItem(int itemID, String itemValue) { 4136 try { 4137 ITelephony telephony = getITelephony(); 4138 if (telephony != null) 4139 return telephony.nvWriteItem(itemID, itemValue); 4140 } catch (RemoteException ex) { 4141 Rlog.e(TAG, "nvWriteItem RemoteException", ex); 4142 } catch (NullPointerException ex) { 4143 Rlog.e(TAG, "nvWriteItem NPE", ex); 4144 } 4145 return false; 4146 } 4147 4148 /** 4149 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage. 4150 * Used for device configuration by some CDMA operators. 4151 * <p> 4152 * Requires Permission: 4153 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4154 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4155 * 4156 * @param preferredRoamingList byte array containing the new PRL. 4157 * @return true on success; false on any failure. 4158 * 4159 * @hide 4160 */ nvWriteCdmaPrl(byte[] preferredRoamingList)4161 public boolean nvWriteCdmaPrl(byte[] preferredRoamingList) { 4162 try { 4163 ITelephony telephony = getITelephony(); 4164 if (telephony != null) 4165 return telephony.nvWriteCdmaPrl(preferredRoamingList); 4166 } catch (RemoteException ex) { 4167 Rlog.e(TAG, "nvWriteCdmaPrl RemoteException", ex); 4168 } catch (NullPointerException ex) { 4169 Rlog.e(TAG, "nvWriteCdmaPrl NPE", ex); 4170 } 4171 return false; 4172 } 4173 4174 /** 4175 * Perform the specified type of NV config reset. The radio will be taken offline 4176 * and the device must be rebooted after the operation. Used for device 4177 * configuration by some CDMA operators. 4178 * <p> 4179 * Requires Permission: 4180 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4181 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4182 * 4183 * @param resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset 4184 * @return true on success; false on any failure. 4185 * 4186 * @hide 4187 */ nvResetConfig(int resetType)4188 public boolean nvResetConfig(int resetType) { 4189 try { 4190 ITelephony telephony = getITelephony(); 4191 if (telephony != null) 4192 return telephony.nvResetConfig(resetType); 4193 } catch (RemoteException ex) { 4194 Rlog.e(TAG, "nvResetConfig RemoteException", ex); 4195 } catch (NullPointerException ex) { 4196 Rlog.e(TAG, "nvResetConfig NPE", ex); 4197 } 4198 return false; 4199 } 4200 4201 /** 4202 * Return an appropriate subscription ID for any situation. 4203 * 4204 * If this object has been created with {@link #createForSubscriptionId}, then the provided 4205 * subId is returned. Otherwise, the default subId will be returned. 4206 */ getSubId()4207 private int getSubId() { 4208 if (SubscriptionManager.isUsableSubIdValue(mSubId)) { 4209 return mSubId; 4210 } 4211 return SubscriptionManager.getDefaultSubscriptionId(); 4212 } 4213 4214 /** 4215 * Return an appropriate subscription ID for any situation. 4216 * 4217 * If this object has been created with {@link #createForSubscriptionId}, then the provided 4218 * subId is returned. Otherwise, the preferred subId which is based on caller's context is 4219 * returned. 4220 * {@see SubscriptionManager#getDefaultDataSubscriptionId()} 4221 * {@see SubscriptionManager#getDefaultVoiceSubscriptionId()} 4222 * {@see SubscriptionManager#getDefaultSmsSubscriptionId()} 4223 */ getSubId(int preferredSubId)4224 private int getSubId(int preferredSubId) { 4225 if (SubscriptionManager.isUsableSubIdValue(mSubId)) { 4226 return mSubId; 4227 } 4228 return preferredSubId; 4229 } 4230 4231 /** 4232 * Return an appropriate phone ID for any situation. 4233 * 4234 * If this object has been created with {@link #createForSubscriptionId}, then the phoneId 4235 * associated with the provided subId is returned. Otherwise, the default phoneId associated 4236 * with the default subId will be returned. 4237 */ getPhoneId()4238 private int getPhoneId() { 4239 return SubscriptionManager.getPhoneId(getSubId()); 4240 } 4241 4242 /** 4243 * Return an appropriate phone ID for any situation. 4244 * 4245 * If this object has been created with {@link #createForSubscriptionId}, then the phoneId 4246 * associated with the provided subId is returned. Otherwise, return the phoneId associated 4247 * with the preferred subId based on caller's context. 4248 * {@see SubscriptionManager#getDefaultDataSubscriptionId()} 4249 * {@see SubscriptionManager#getDefaultVoiceSubscriptionId()} 4250 * {@see SubscriptionManager#getDefaultSmsSubscriptionId()} 4251 */ getPhoneId(int preferredSubId)4252 private int getPhoneId(int preferredSubId) { 4253 return SubscriptionManager.getPhoneId(getSubId(preferredSubId)); 4254 } 4255 4256 /** 4257 * Return an appropriate slot index for any situation. 4258 * 4259 * if this object has been created with {@link #createForSubscriptionId}, then the slot index 4260 * associated with the provided subId is returned. Otherwise, return the slot index associated 4261 * with the default subId. 4262 * If SIM is not inserted, return default SIM slot index. 4263 * 4264 * {@hide} 4265 */ 4266 @VisibleForTesting getSlotIndex()4267 public int getSlotIndex() { 4268 int slotIndex = SubscriptionManager.getSlotIndex(getSubId()); 4269 if (slotIndex == SubscriptionManager.SIM_NOT_INSERTED) { 4270 slotIndex = SubscriptionManager.DEFAULT_SIM_SLOT_INDEX; 4271 } 4272 return slotIndex; 4273 } 4274 4275 /** 4276 * Sets the telephony property with the value specified. 4277 * 4278 * @hide 4279 */ setTelephonyProperty(int phoneId, String property, String value)4280 public static void setTelephonyProperty(int phoneId, String property, String value) { 4281 String propVal = ""; 4282 String p[] = null; 4283 String prop = SystemProperties.get(property); 4284 4285 if (value == null) { 4286 value = ""; 4287 } 4288 4289 if (prop != null) { 4290 p = prop.split(","); 4291 } 4292 4293 if (!SubscriptionManager.isValidPhoneId(phoneId)) { 4294 Rlog.d(TAG, "setTelephonyProperty: invalid phoneId=" + phoneId + 4295 " property=" + property + " value: " + value + " prop=" + prop); 4296 return; 4297 } 4298 4299 for (int i = 0; i < phoneId; i++) { 4300 String str = ""; 4301 if ((p != null) && (i < p.length)) { 4302 str = p[i]; 4303 } 4304 propVal = propVal + str + ","; 4305 } 4306 4307 propVal = propVal + value; 4308 if (p != null) { 4309 for (int i = phoneId + 1; i < p.length; i++) { 4310 propVal = propVal + "," + p[i]; 4311 } 4312 } 4313 4314 if (propVal.length() > SystemProperties.PROP_VALUE_MAX) { 4315 Rlog.d(TAG, "setTelephonyProperty: property too long phoneId=" + phoneId + 4316 " property=" + property + " value: " + value + " propVal=" + propVal); 4317 return; 4318 } 4319 4320 Rlog.d(TAG, "setTelephonyProperty: success phoneId=" + phoneId + 4321 " property=" + property + " value: " + value + " propVal=" + propVal); 4322 SystemProperties.set(property, propVal); 4323 } 4324 4325 /** 4326 * Convenience function for retrieving a value from the secure settings 4327 * value list as an integer. Note that internally setting values are 4328 * always stored as strings; this function converts the string to an 4329 * integer for you. 4330 * <p> 4331 * This version does not take a default value. If the setting has not 4332 * been set, or the string value is not a number, 4333 * it throws {@link SettingNotFoundException}. 4334 * 4335 * @param cr The ContentResolver to access. 4336 * @param name The name of the setting to retrieve. 4337 * @param index The index of the list 4338 * 4339 * @throws SettingNotFoundException Thrown if a setting by the given 4340 * name can't be found or the setting value is not an integer. 4341 * 4342 * @return The value at the given index of settings. 4343 * @hide 4344 */ getIntAtIndex(android.content.ContentResolver cr, String name, int index)4345 public static int getIntAtIndex(android.content.ContentResolver cr, 4346 String name, int index) 4347 throws android.provider.Settings.SettingNotFoundException { 4348 String v = android.provider.Settings.Global.getString(cr, name); 4349 if (v != null) { 4350 String valArray[] = v.split(","); 4351 if ((index >= 0) && (index < valArray.length) && (valArray[index] != null)) { 4352 try { 4353 return Integer.parseInt(valArray[index]); 4354 } catch (NumberFormatException e) { 4355 //Log.e(TAG, "Exception while parsing Integer: ", e); 4356 } 4357 } 4358 } 4359 throw new android.provider.Settings.SettingNotFoundException(name); 4360 } 4361 4362 /** 4363 * Convenience function for updating settings value as coma separated 4364 * integer values. This will either create a new entry in the table if the 4365 * given name does not exist, or modify the value of the existing row 4366 * with that name. Note that internally setting values are always 4367 * stored as strings, so this function converts the given value to a 4368 * string before storing it. 4369 * 4370 * @param cr The ContentResolver to access. 4371 * @param name The name of the setting to modify. 4372 * @param index The index of the list 4373 * @param value The new value for the setting to be added to the list. 4374 * @return true if the value was set, false on database errors 4375 * @hide 4376 */ putIntAtIndex(android.content.ContentResolver cr, String name, int index, int value)4377 public static boolean putIntAtIndex(android.content.ContentResolver cr, 4378 String name, int index, int value) { 4379 String data = ""; 4380 String valArray[] = null; 4381 String v = android.provider.Settings.Global.getString(cr, name); 4382 4383 if (index == Integer.MAX_VALUE) { 4384 throw new RuntimeException("putIntAtIndex index == MAX_VALUE index=" + index); 4385 } 4386 if (index < 0) { 4387 throw new RuntimeException("putIntAtIndex index < 0 index=" + index); 4388 } 4389 if (v != null) { 4390 valArray = v.split(","); 4391 } 4392 4393 // Copy the elements from valArray till index 4394 for (int i = 0; i < index; i++) { 4395 String str = ""; 4396 if ((valArray != null) && (i < valArray.length)) { 4397 str = valArray[i]; 4398 } 4399 data = data + str + ","; 4400 } 4401 4402 data = data + value; 4403 4404 // Copy the remaining elements from valArray if any. 4405 if (valArray != null) { 4406 for (int i = index+1; i < valArray.length; i++) { 4407 data = data + "," + valArray[i]; 4408 } 4409 } 4410 return android.provider.Settings.Global.putString(cr, name, data); 4411 } 4412 4413 /** 4414 * Gets the telephony property. 4415 * 4416 * @hide 4417 */ getTelephonyProperty(int phoneId, String property, String defaultVal)4418 public static String getTelephonyProperty(int phoneId, String property, String defaultVal) { 4419 String propVal = null; 4420 String prop = SystemProperties.get(property); 4421 if ((prop != null) && (prop.length() > 0)) { 4422 String values[] = prop.split(","); 4423 if ((phoneId >= 0) && (phoneId < values.length) && (values[phoneId] != null)) { 4424 propVal = values[phoneId]; 4425 } 4426 } 4427 return propVal == null ? defaultVal : propVal; 4428 } 4429 4430 /** @hide */ getSimCount()4431 public int getSimCount() { 4432 // FIXME Need to get it from Telephony Dev Controller when that gets implemented! 4433 // and then this method shouldn't be used at all! 4434 if(isMultiSimEnabled()) { 4435 return 2; 4436 } else { 4437 return 1; 4438 } 4439 } 4440 4441 /** 4442 * Returns the IMS Service Table (IST) that was loaded from the ISIM. 4443 * @return IMS Service Table or null if not present or not loaded 4444 * @hide 4445 */ getIsimIst()4446 public String getIsimIst() { 4447 try { 4448 IPhoneSubInfo info = getSubscriberInfo(); 4449 if (info == null) 4450 return null; 4451 return info.getIsimIst(); 4452 } catch (RemoteException ex) { 4453 return null; 4454 } catch (NullPointerException ex) { 4455 // This could happen before phone restarts due to crashing 4456 return null; 4457 } 4458 } 4459 4460 /** 4461 * Returns the IMS Proxy Call Session Control Function(PCSCF) that were loaded from the ISIM. 4462 * @return an array of PCSCF strings with one PCSCF per string, or null if 4463 * not present or not loaded 4464 * @hide 4465 */ getIsimPcscf()4466 public String[] getIsimPcscf() { 4467 try { 4468 IPhoneSubInfo info = getSubscriberInfo(); 4469 if (info == null) 4470 return null; 4471 return info.getIsimPcscf(); 4472 } catch (RemoteException ex) { 4473 return null; 4474 } catch (NullPointerException ex) { 4475 // This could happen before phone restarts due to crashing 4476 return null; 4477 } 4478 } 4479 4480 /** 4481 * Returns the response of ISIM Authetification through RIL. 4482 * Returns null if the Authentification hasn't been successed or isn't present iphonesubinfo. 4483 * @return the response of ISIM Authetification, or null if not available 4484 * @hide 4485 * @deprecated 4486 * @see getIccAuthentication with appType=PhoneConstants.APPTYPE_ISIM 4487 */ getIsimChallengeResponse(String nonce)4488 public String getIsimChallengeResponse(String nonce){ 4489 try { 4490 IPhoneSubInfo info = getSubscriberInfo(); 4491 if (info == null) 4492 return null; 4493 return info.getIsimChallengeResponse(nonce); 4494 } catch (RemoteException ex) { 4495 return null; 4496 } catch (NullPointerException ex) { 4497 // This could happen before phone restarts due to crashing 4498 return null; 4499 } 4500 } 4501 4502 // ICC SIM Application Types 4503 /** UICC application type is SIM */ 4504 public static final int APPTYPE_SIM = PhoneConstants.APPTYPE_SIM; 4505 /** UICC application type is USIM */ 4506 public static final int APPTYPE_USIM = PhoneConstants.APPTYPE_USIM; 4507 /** UICC application type is RUIM */ 4508 public static final int APPTYPE_RUIM = PhoneConstants.APPTYPE_RUIM; 4509 /** UICC application type is CSIM */ 4510 public static final int APPTYPE_CSIM = PhoneConstants.APPTYPE_CSIM; 4511 /** UICC application type is ISIM */ 4512 public static final int APPTYPE_ISIM = PhoneConstants.APPTYPE_ISIM; 4513 // authContext (parameter P2) when doing UICC challenge, 4514 // per 3GPP TS 31.102 (Section 7.1.2) 4515 /** Authentication type for UICC challenge is EAP SIM. See RFC 4186 for details. */ 4516 public static final int AUTHTYPE_EAP_SIM = PhoneConstants.AUTH_CONTEXT_EAP_SIM; 4517 /** Authentication type for UICC challenge is EAP AKA. See RFC 4187 for details. */ 4518 public static final int AUTHTYPE_EAP_AKA = PhoneConstants.AUTH_CONTEXT_EAP_AKA; 4519 4520 /** 4521 * Returns the response of authentication for the default subscription. 4522 * Returns null if the authentication hasn't been successful 4523 * 4524 * <p>Requires that the calling app has carrier privileges or READ_PRIVILEGED_PHONE_STATE 4525 * permission. 4526 * 4527 * @param appType the icc application type, like {@link #APPTYPE_USIM} 4528 * @param authType the authentication type, {@link #AUTHTYPE_EAP_AKA} or 4529 * {@link #AUTHTYPE_EAP_SIM} 4530 * @param data authentication challenge data, base64 encoded. 4531 * See 3GPP TS 31.102 7.1.2 for more details. 4532 * @return the response of authentication, or null if not available 4533 * 4534 * @see #hasCarrierPrivileges 4535 */ getIccAuthentication(int appType, int authType, String data)4536 public String getIccAuthentication(int appType, int authType, String data) { 4537 return getIccAuthentication(getSubId(), appType, authType, data); 4538 } 4539 4540 /** 4541 * Returns the response of USIM Authentication for specified subId. 4542 * Returns null if the authentication hasn't been successful 4543 * 4544 * <p>Requires that the calling app has carrier privileges. 4545 * 4546 * @param subId subscription ID used for authentication 4547 * @param appType the icc application type, like {@link #APPTYPE_USIM} 4548 * @param authType the authentication type, {@link #AUTHTYPE_EAP_AKA} or 4549 * {@link #AUTHTYPE_EAP_SIM} 4550 * @param data authentication challenge data, base64 encoded. 4551 * See 3GPP TS 31.102 7.1.2 for more details. 4552 * @return the response of authentication, or null if not available 4553 * 4554 * @see #hasCarrierPrivileges 4555 * @hide 4556 */ getIccAuthentication(int subId, int appType, int authType, String data)4557 public String getIccAuthentication(int subId, int appType, int authType, String data) { 4558 try { 4559 IPhoneSubInfo info = getSubscriberInfo(); 4560 if (info == null) 4561 return null; 4562 return info.getIccSimChallengeResponse(subId, appType, authType, data); 4563 } catch (RemoteException ex) { 4564 return null; 4565 } catch (NullPointerException ex) { 4566 // This could happen before phone starts 4567 return null; 4568 } 4569 } 4570 4571 /** 4572 * Returns an array of Forbidden PLMNs from the USIM App 4573 * Returns null if the query fails. 4574 * 4575 * @return an array of forbidden PLMNs or null if not available 4576 */ 4577 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getForbiddenPlmns()4578 public String[] getForbiddenPlmns() { 4579 return getForbiddenPlmns(getSubId(), APPTYPE_USIM); 4580 } 4581 4582 /** 4583 * Returns an array of Forbidden PLMNs from the specified SIM App 4584 * Returns null if the query fails. 4585 * 4586 * @param subId subscription ID used for authentication 4587 * @param appType the icc application type, like {@link #APPTYPE_USIM} 4588 * @return fplmns an array of forbidden PLMNs 4589 * @hide 4590 */ 4591 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getForbiddenPlmns(int subId, int appType)4592 public String[] getForbiddenPlmns(int subId, int appType) { 4593 try { 4594 ITelephony telephony = getITelephony(); 4595 if (telephony == null) 4596 return null; 4597 return telephony.getForbiddenPlmns(subId, appType, mContext.getOpPackageName()); 4598 } catch (RemoteException ex) { 4599 return null; 4600 } catch (NullPointerException ex) { 4601 // This could happen before phone starts 4602 return null; 4603 } 4604 } 4605 4606 /** 4607 * Get P-CSCF address from PCO after data connection is established or modified. 4608 * @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN 4609 * @return array of P-CSCF address 4610 * @hide 4611 */ getPcscfAddress(String apnType)4612 public String[] getPcscfAddress(String apnType) { 4613 try { 4614 ITelephony telephony = getITelephony(); 4615 if (telephony == null) 4616 return new String[0]; 4617 return telephony.getPcscfAddress(apnType, getOpPackageName()); 4618 } catch (RemoteException e) { 4619 return new String[0]; 4620 } 4621 } 4622 4623 /** @hide */ 4624 @IntDef({ImsFeature.EMERGENCY_MMTEL, ImsFeature.MMTEL, ImsFeature.RCS}) 4625 @Retention(RetentionPolicy.SOURCE) 4626 public @interface Feature {} 4627 4628 /** 4629 * Returns the {@link IImsServiceController} that corresponds to the given slot Id and IMS 4630 * feature or {@link null} if the service is not available. If an ImsServiceController is 4631 * available, the {@link IImsServiceFeatureListener} callback is registered as a listener for 4632 * feature updates. 4633 * @param slotIndex The SIM slot that we are requesting the {@link IImsServiceController} for. 4634 * @param feature The IMS Feature we are requesting, corresponding to {@link ImsFeature}. 4635 * @param callback Listener that will send updates to ImsManager when there are updates to 4636 * ImsServiceController. 4637 * @return {@link IImsServiceController} interface for the feature specified or {@link null} if 4638 * it is unavailable. 4639 * @hide 4640 */ getImsServiceControllerAndListen(int slotIndex, @Feature int feature, IImsServiceFeatureListener callback)4641 public IImsServiceController getImsServiceControllerAndListen(int slotIndex, @Feature int feature, 4642 IImsServiceFeatureListener callback) { 4643 try { 4644 ITelephony telephony = getITelephony(); 4645 if (telephony != null) { 4646 return telephony.getImsServiceControllerAndListen(slotIndex, feature, callback); 4647 } 4648 } catch (RemoteException e) { 4649 Rlog.e(TAG, "getImsServiceControllerAndListen, RemoteException: " + e.getMessage()); 4650 } 4651 return null; 4652 } 4653 4654 /** 4655 * Set IMS registration state 4656 * 4657 * @param Registration state 4658 * @hide 4659 */ setImsRegistrationState(boolean registered)4660 public void setImsRegistrationState(boolean registered) { 4661 try { 4662 ITelephony telephony = getITelephony(); 4663 if (telephony != null) 4664 telephony.setImsRegistrationState(registered); 4665 } catch (RemoteException e) { 4666 } 4667 } 4668 4669 /** 4670 * Get the preferred network type. 4671 * Used for device configuration by some CDMA operators. 4672 * <p> 4673 * Requires Permission: 4674 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4675 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4676 * 4677 * @return the preferred network type, defined in RILConstants.java. 4678 * @hide 4679 */ getPreferredNetworkType(int subId)4680 public int getPreferredNetworkType(int subId) { 4681 try { 4682 ITelephony telephony = getITelephony(); 4683 if (telephony != null) 4684 return telephony.getPreferredNetworkType(subId); 4685 } catch (RemoteException ex) { 4686 Rlog.e(TAG, "getPreferredNetworkType RemoteException", ex); 4687 } catch (NullPointerException ex) { 4688 Rlog.e(TAG, "getPreferredNetworkType NPE", ex); 4689 } 4690 return -1; 4691 } 4692 4693 /** 4694 * Sets the network selection mode to automatic. 4695 * <p> 4696 * Requires Permission: 4697 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4698 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4699 * 4700 * @hide 4701 * TODO: Add an overload that takes no args. 4702 */ setNetworkSelectionModeAutomatic(int subId)4703 public void setNetworkSelectionModeAutomatic(int subId) { 4704 try { 4705 ITelephony telephony = getITelephony(); 4706 if (telephony != null) 4707 telephony.setNetworkSelectionModeAutomatic(subId); 4708 } catch (RemoteException ex) { 4709 Rlog.e(TAG, "setNetworkSelectionModeAutomatic RemoteException", ex); 4710 } catch (NullPointerException ex) { 4711 Rlog.e(TAG, "setNetworkSelectionModeAutomatic NPE", ex); 4712 } 4713 } 4714 4715 /** 4716 * Perform a radio scan and return the list of avialble networks. 4717 * 4718 * The return value is a list of the OperatorInfo of the networks found. Note that this 4719 * scan can take a long time (sometimes minutes) to happen. 4720 * 4721 * <p> 4722 * Requires Permission: 4723 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4724 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4725 * 4726 * @hide 4727 * TODO: Add an overload that takes no args. 4728 */ getCellNetworkScanResults(int subId)4729 public CellNetworkScanResult getCellNetworkScanResults(int subId) { 4730 try { 4731 ITelephony telephony = getITelephony(); 4732 if (telephony != null) 4733 return telephony.getCellNetworkScanResults(subId); 4734 } catch (RemoteException ex) { 4735 Rlog.e(TAG, "getCellNetworkScanResults RemoteException", ex); 4736 } catch (NullPointerException ex) { 4737 Rlog.e(TAG, "getCellNetworkScanResults NPE", ex); 4738 } 4739 return null; 4740 } 4741 4742 /** 4743 * Request a network scan. 4744 * 4745 * This method is asynchronous, so the network scan results will be returned by callback. 4746 * The returned NetworkScan will contain a callback method which can be used to stop the scan. 4747 * 4748 * <p> 4749 * Requires Permission: 4750 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4751 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4752 * 4753 * @param request Contains all the RAT with bands/channels that need to be scanned. 4754 * @param callback Returns network scan results or errors. 4755 * @return A NetworkScan obj which contains a callback which can stop the scan. 4756 * @hide 4757 */ requestNetworkScan( NetworkScanRequest request, TelephonyScanManager.NetworkScanCallback callback)4758 public NetworkScan requestNetworkScan( 4759 NetworkScanRequest request, TelephonyScanManager.NetworkScanCallback callback) { 4760 synchronized (this) { 4761 if (mTelephonyScanManager == null) { 4762 mTelephonyScanManager = new TelephonyScanManager(); 4763 } 4764 } 4765 return mTelephonyScanManager.requestNetworkScan(getSubId(), request, callback); 4766 } 4767 4768 /** 4769 * Ask the radio to connect to the input network and change selection mode to manual. 4770 * 4771 * <p> 4772 * Requires Permission: 4773 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4774 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4775 * 4776 * @hide 4777 * TODO: Add an overload that takes no args. 4778 */ setNetworkSelectionModeManual(int subId, OperatorInfo operator, boolean persistSelection)4779 public boolean setNetworkSelectionModeManual(int subId, OperatorInfo operator, 4780 boolean persistSelection) { 4781 try { 4782 ITelephony telephony = getITelephony(); 4783 if (telephony != null) 4784 return telephony.setNetworkSelectionModeManual(subId, operator, persistSelection); 4785 } catch (RemoteException ex) { 4786 Rlog.e(TAG, "setNetworkSelectionModeManual RemoteException", ex); 4787 } catch (NullPointerException ex) { 4788 Rlog.e(TAG, "setNetworkSelectionModeManual NPE", ex); 4789 } 4790 return false; 4791 } 4792 4793 /** 4794 * Set the preferred network type. 4795 * Used for device configuration by some CDMA operators. 4796 * <p> 4797 * Requires Permission: 4798 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 4799 * Or the calling app has carrier privileges. @see #hasCarrierPrivileges 4800 * 4801 * @param subId the id of the subscription to set the preferred network type for. 4802 * @param networkType the preferred network type, defined in RILConstants.java. 4803 * @return true on success; false on any failure. 4804 * @hide 4805 */ setPreferredNetworkType(int subId, int networkType)4806 public boolean setPreferredNetworkType(int subId, int networkType) { 4807 try { 4808 ITelephony telephony = getITelephony(); 4809 if (telephony != null) 4810 return telephony.setPreferredNetworkType(subId, networkType); 4811 } catch (RemoteException ex) { 4812 Rlog.e(TAG, "setPreferredNetworkType RemoteException", ex); 4813 } catch (NullPointerException ex) { 4814 Rlog.e(TAG, "setPreferredNetworkType NPE", ex); 4815 } 4816 return false; 4817 } 4818 4819 /** 4820 * Set the preferred network type to global mode which includes LTE, CDMA, EvDo and GSM/WCDMA. 4821 * 4822 * <p> 4823 * Requires that the calling app has carrier privileges. 4824 * @see #hasCarrierPrivileges 4825 * 4826 * @return true on success; false on any failure. 4827 */ setPreferredNetworkTypeToGlobal()4828 public boolean setPreferredNetworkTypeToGlobal() { 4829 return setPreferredNetworkTypeToGlobal(getSubId()); 4830 } 4831 4832 /** 4833 * Set the preferred network type to global mode which includes LTE, CDMA, EvDo and GSM/WCDMA. 4834 * 4835 * <p> 4836 * Requires that the calling app has carrier privileges. 4837 * @see #hasCarrierPrivileges 4838 * 4839 * @return true on success; false on any failure. 4840 * @hide 4841 */ setPreferredNetworkTypeToGlobal(int subId)4842 public boolean setPreferredNetworkTypeToGlobal(int subId) { 4843 return setPreferredNetworkType(subId, RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); 4844 } 4845 4846 /** 4847 * Check TETHER_DUN_REQUIRED and TETHER_DUN_APN settings, net.tethering.noprovisioning 4848 * SystemProperty, and config_tether_apndata to decide whether DUN APN is required for 4849 * tethering. 4850 * 4851 * @return 0: Not required. 1: required. 2: Not set. 4852 * @hide 4853 */ getTetherApnRequired()4854 public int getTetherApnRequired() { 4855 try { 4856 ITelephony telephony = getITelephony(); 4857 if (telephony != null) 4858 return telephony.getTetherApnRequired(); 4859 } catch (RemoteException ex) { 4860 Rlog.e(TAG, "hasMatchedTetherApnSetting RemoteException", ex); 4861 } catch (NullPointerException ex) { 4862 Rlog.e(TAG, "hasMatchedTetherApnSetting NPE", ex); 4863 } 4864 return 2; 4865 } 4866 4867 4868 /** 4869 * Values used to return status for hasCarrierPrivileges call. 4870 */ 4871 /** @hide */ @SystemApi 4872 public static final int CARRIER_PRIVILEGE_STATUS_HAS_ACCESS = 1; 4873 /** @hide */ @SystemApi 4874 public static final int CARRIER_PRIVILEGE_STATUS_NO_ACCESS = 0; 4875 /** @hide */ @SystemApi 4876 public static final int CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED = -1; 4877 /** @hide */ @SystemApi 4878 public static final int CARRIER_PRIVILEGE_STATUS_ERROR_LOADING_RULES = -2; 4879 4880 /** 4881 * Has the calling application been granted carrier privileges by the carrier. 4882 * 4883 * If any of the packages in the calling UID has carrier privileges, the 4884 * call will return true. This access is granted by the owner of the UICC 4885 * card and does not depend on the registered carrier. 4886 * 4887 * @return true if the app has carrier privileges. 4888 */ hasCarrierPrivileges()4889 public boolean hasCarrierPrivileges() { 4890 return hasCarrierPrivileges(getSubId()); 4891 } 4892 4893 /** 4894 * Has the calling application been granted carrier privileges by the carrier. 4895 * 4896 * If any of the packages in the calling UID has carrier privileges, the 4897 * call will return true. This access is granted by the owner of the UICC 4898 * card and does not depend on the registered carrier. 4899 * 4900 * @param subId The subscription to use. 4901 * @return true if the app has carrier privileges. 4902 * @hide 4903 */ hasCarrierPrivileges(int subId)4904 public boolean hasCarrierPrivileges(int subId) { 4905 try { 4906 ITelephony telephony = getITelephony(); 4907 if (telephony != null) { 4908 return telephony.getCarrierPrivilegeStatus(mSubId) == 4909 CARRIER_PRIVILEGE_STATUS_HAS_ACCESS; 4910 } 4911 } catch (RemoteException ex) { 4912 Rlog.e(TAG, "hasCarrierPrivileges RemoteException", ex); 4913 } catch (NullPointerException ex) { 4914 Rlog.e(TAG, "hasCarrierPrivileges NPE", ex); 4915 } 4916 return false; 4917 } 4918 4919 /** 4920 * Override the branding for the current ICCID. 4921 * 4922 * Once set, whenever the SIM is present in the device, the service 4923 * provider name (SPN) and the operator name will both be replaced by the 4924 * brand value input. To unset the value, the same function should be 4925 * called with a null brand value. 4926 * 4927 * <p>Requires that the calling app has carrier privileges. 4928 * @see #hasCarrierPrivileges 4929 * 4930 * @param brand The brand name to display/set. 4931 * @return true if the operation was executed correctly. 4932 */ setOperatorBrandOverride(String brand)4933 public boolean setOperatorBrandOverride(String brand) { 4934 return setOperatorBrandOverride(getSubId(), brand); 4935 } 4936 4937 /** 4938 * Override the branding for the current ICCID. 4939 * 4940 * Once set, whenever the SIM is present in the device, the service 4941 * provider name (SPN) and the operator name will both be replaced by the 4942 * brand value input. To unset the value, the same function should be 4943 * called with a null brand value. 4944 * 4945 * <p>Requires that the calling app has carrier privileges. 4946 * @see #hasCarrierPrivileges 4947 * 4948 * @param subId The subscription to use. 4949 * @param brand The brand name to display/set. 4950 * @return true if the operation was executed correctly. 4951 * @hide 4952 */ setOperatorBrandOverride(int subId, String brand)4953 public boolean setOperatorBrandOverride(int subId, String brand) { 4954 try { 4955 ITelephony telephony = getITelephony(); 4956 if (telephony != null) 4957 return telephony.setOperatorBrandOverride(subId, brand); 4958 } catch (RemoteException ex) { 4959 Rlog.e(TAG, "setOperatorBrandOverride RemoteException", ex); 4960 } catch (NullPointerException ex) { 4961 Rlog.e(TAG, "setOperatorBrandOverride NPE", ex); 4962 } 4963 return false; 4964 } 4965 4966 /** 4967 * Override the roaming preference for the current ICCID. 4968 * 4969 * Using this call, the carrier app (see #hasCarrierPrivileges) can override 4970 * the platform's notion of a network operator being considered roaming or not. 4971 * The change only affects the ICCID that was active when this call was made. 4972 * 4973 * If null is passed as any of the input, the corresponding value is deleted. 4974 * 4975 * <p>Requires that the caller have carrier privilege. See #hasCarrierPrivileges. 4976 * 4977 * @param gsmRoamingList - List of MCCMNCs to be considered roaming for 3GPP RATs. 4978 * @param gsmNonRoamingList - List of MCCMNCs to be considered not roaming for 3GPP RATs. 4979 * @param cdmaRoamingList - List of SIDs to be considered roaming for 3GPP2 RATs. 4980 * @param cdmaNonRoamingList - List of SIDs to be considered not roaming for 3GPP2 RATs. 4981 * @return true if the operation was executed correctly. 4982 * 4983 * @hide 4984 */ setRoamingOverride(List<String> gsmRoamingList, List<String> gsmNonRoamingList, List<String> cdmaRoamingList, List<String> cdmaNonRoamingList)4985 public boolean setRoamingOverride(List<String> gsmRoamingList, 4986 List<String> gsmNonRoamingList, List<String> cdmaRoamingList, 4987 List<String> cdmaNonRoamingList) { 4988 return setRoamingOverride(getSubId(), gsmRoamingList, gsmNonRoamingList, 4989 cdmaRoamingList, cdmaNonRoamingList); 4990 } 4991 4992 /** 4993 * Override the roaming preference for the current ICCID. 4994 * 4995 * Using this call, the carrier app (see #hasCarrierPrivileges) can override 4996 * the platform's notion of a network operator being considered roaming or not. 4997 * The change only affects the ICCID that was active when this call was made. 4998 * 4999 * If null is passed as any of the input, the corresponding value is deleted. 5000 * 5001 * <p>Requires that the caller have carrier privilege. See #hasCarrierPrivileges. 5002 * 5003 * @param subId for which the roaming overrides apply. 5004 * @param gsmRoamingList - List of MCCMNCs to be considered roaming for 3GPP RATs. 5005 * @param gsmNonRoamingList - List of MCCMNCs to be considered not roaming for 3GPP RATs. 5006 * @param cdmaRoamingList - List of SIDs to be considered roaming for 3GPP2 RATs. 5007 * @param cdmaNonRoamingList - List of SIDs to be considered not roaming for 3GPP2 RATs. 5008 * @return true if the operation was executed correctly. 5009 * 5010 * @hide 5011 */ setRoamingOverride(int subId, List<String> gsmRoamingList, List<String> gsmNonRoamingList, List<String> cdmaRoamingList, List<String> cdmaNonRoamingList)5012 public boolean setRoamingOverride(int subId, List<String> gsmRoamingList, 5013 List<String> gsmNonRoamingList, List<String> cdmaRoamingList, 5014 List<String> cdmaNonRoamingList) { 5015 try { 5016 ITelephony telephony = getITelephony(); 5017 if (telephony != null) 5018 return telephony.setRoamingOverride(subId, gsmRoamingList, gsmNonRoamingList, 5019 cdmaRoamingList, cdmaNonRoamingList); 5020 } catch (RemoteException ex) { 5021 Rlog.e(TAG, "setRoamingOverride RemoteException", ex); 5022 } catch (NullPointerException ex) { 5023 Rlog.e(TAG, "setRoamingOverride NPE", ex); 5024 } 5025 return false; 5026 } 5027 5028 /** 5029 * Expose the rest of ITelephony to @SystemApi 5030 */ 5031 5032 /** @hide */ 5033 @SystemApi 5034 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getCdmaMdn()5035 public String getCdmaMdn() { 5036 return getCdmaMdn(getSubId()); 5037 } 5038 5039 /** @hide */ 5040 @SystemApi 5041 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getCdmaMdn(int subId)5042 public String getCdmaMdn(int subId) { 5043 try { 5044 ITelephony telephony = getITelephony(); 5045 if (telephony == null) 5046 return null; 5047 return telephony.getCdmaMdn(subId); 5048 } catch (RemoteException ex) { 5049 return null; 5050 } catch (NullPointerException ex) { 5051 return null; 5052 } 5053 } 5054 5055 /** @hide */ 5056 @SystemApi 5057 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getCdmaMin()5058 public String getCdmaMin() { 5059 return getCdmaMin(getSubId()); 5060 } 5061 5062 /** @hide */ 5063 @SystemApi 5064 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getCdmaMin(int subId)5065 public String getCdmaMin(int subId) { 5066 try { 5067 ITelephony telephony = getITelephony(); 5068 if (telephony == null) 5069 return null; 5070 return telephony.getCdmaMin(subId); 5071 } catch (RemoteException ex) { 5072 return null; 5073 } catch (NullPointerException ex) { 5074 return null; 5075 } 5076 } 5077 5078 /** @hide */ 5079 @SystemApi 5080 @SuppressLint("Doclava125") checkCarrierPrivilegesForPackage(String pkgName)5081 public int checkCarrierPrivilegesForPackage(String pkgName) { 5082 try { 5083 ITelephony telephony = getITelephony(); 5084 if (telephony != null) 5085 return telephony.checkCarrierPrivilegesForPackage(pkgName); 5086 } catch (RemoteException ex) { 5087 Rlog.e(TAG, "checkCarrierPrivilegesForPackage RemoteException", ex); 5088 } catch (NullPointerException ex) { 5089 Rlog.e(TAG, "checkCarrierPrivilegesForPackage NPE", ex); 5090 } 5091 return CARRIER_PRIVILEGE_STATUS_NO_ACCESS; 5092 } 5093 5094 /** @hide */ 5095 @SystemApi 5096 @SuppressLint("Doclava125") checkCarrierPrivilegesForPackageAnyPhone(String pkgName)5097 public int checkCarrierPrivilegesForPackageAnyPhone(String pkgName) { 5098 try { 5099 ITelephony telephony = getITelephony(); 5100 if (telephony != null) 5101 return telephony.checkCarrierPrivilegesForPackageAnyPhone(pkgName); 5102 } catch (RemoteException ex) { 5103 Rlog.e(TAG, "checkCarrierPrivilegesForPackageAnyPhone RemoteException", ex); 5104 } catch (NullPointerException ex) { 5105 Rlog.e(TAG, "checkCarrierPrivilegesForPackageAnyPhone NPE", ex); 5106 } 5107 return CARRIER_PRIVILEGE_STATUS_NO_ACCESS; 5108 } 5109 5110 /** @hide */ 5111 @SystemApi getCarrierPackageNamesForIntent(Intent intent)5112 public List<String> getCarrierPackageNamesForIntent(Intent intent) { 5113 return getCarrierPackageNamesForIntentAndPhone(intent, getPhoneId()); 5114 } 5115 5116 /** @hide */ 5117 @SystemApi getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId)5118 public List<String> getCarrierPackageNamesForIntentAndPhone(Intent intent, int phoneId) { 5119 try { 5120 ITelephony telephony = getITelephony(); 5121 if (telephony != null) 5122 return telephony.getCarrierPackageNamesForIntentAndPhone(intent, phoneId); 5123 } catch (RemoteException ex) { 5124 Rlog.e(TAG, "getCarrierPackageNamesForIntentAndPhone RemoteException", ex); 5125 } catch (NullPointerException ex) { 5126 Rlog.e(TAG, "getCarrierPackageNamesForIntentAndPhone NPE", ex); 5127 } 5128 return null; 5129 } 5130 5131 /** @hide */ getPackagesWithCarrierPrivileges()5132 public List<String> getPackagesWithCarrierPrivileges() { 5133 try { 5134 ITelephony telephony = getITelephony(); 5135 if (telephony != null) { 5136 return telephony.getPackagesWithCarrierPrivileges(); 5137 } 5138 } catch (RemoteException ex) { 5139 Rlog.e(TAG, "getPackagesWithCarrierPrivileges RemoteException", ex); 5140 } catch (NullPointerException ex) { 5141 Rlog.e(TAG, "getPackagesWithCarrierPrivileges NPE", ex); 5142 } 5143 return Collections.EMPTY_LIST; 5144 } 5145 5146 /** @hide */ 5147 @SystemApi 5148 @SuppressLint("Doclava125") dial(String number)5149 public void dial(String number) { 5150 try { 5151 ITelephony telephony = getITelephony(); 5152 if (telephony != null) 5153 telephony.dial(number); 5154 } catch (RemoteException e) { 5155 Log.e(TAG, "Error calling ITelephony#dial", e); 5156 } 5157 } 5158 5159 /** @hide */ 5160 @SystemApi 5161 @RequiresPermission(android.Manifest.permission.CALL_PHONE) call(String callingPackage, String number)5162 public void call(String callingPackage, String number) { 5163 try { 5164 ITelephony telephony = getITelephony(); 5165 if (telephony != null) 5166 telephony.call(callingPackage, number); 5167 } catch (RemoteException e) { 5168 Log.e(TAG, "Error calling ITelephony#call", e); 5169 } 5170 } 5171 5172 /** @hide */ 5173 @SystemApi 5174 @RequiresPermission(android.Manifest.permission.CALL_PHONE) endCall()5175 public boolean endCall() { 5176 try { 5177 ITelephony telephony = getITelephony(); 5178 if (telephony != null) 5179 return telephony.endCall(); 5180 } catch (RemoteException e) { 5181 Log.e(TAG, "Error calling ITelephony#endCall", e); 5182 } 5183 return false; 5184 } 5185 5186 /** @hide */ 5187 @SystemApi 5188 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) answerRingingCall()5189 public void answerRingingCall() { 5190 try { 5191 ITelephony telephony = getITelephony(); 5192 if (telephony != null) 5193 telephony.answerRingingCall(); 5194 } catch (RemoteException e) { 5195 Log.e(TAG, "Error calling ITelephony#answerRingingCall", e); 5196 } 5197 } 5198 5199 /** @hide */ 5200 @SystemApi 5201 @SuppressLint("Doclava125") silenceRinger()5202 public void silenceRinger() { 5203 try { 5204 getTelecomService().silenceRinger(getOpPackageName()); 5205 } catch (RemoteException e) { 5206 Log.e(TAG, "Error calling ITelecomService#silenceRinger", e); 5207 } 5208 } 5209 5210 /** @hide */ 5211 @SystemApi 5212 @RequiresPermission(anyOf = { 5213 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 5214 android.Manifest.permission.READ_PHONE_STATE 5215 }) isOffhook()5216 public boolean isOffhook() { 5217 try { 5218 ITelephony telephony = getITelephony(); 5219 if (telephony != null) 5220 return telephony.isOffhook(getOpPackageName()); 5221 } catch (RemoteException e) { 5222 Log.e(TAG, "Error calling ITelephony#isOffhook", e); 5223 } 5224 return false; 5225 } 5226 5227 /** @hide */ 5228 @SystemApi 5229 @RequiresPermission(anyOf = { 5230 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 5231 android.Manifest.permission.READ_PHONE_STATE 5232 }) isRinging()5233 public boolean isRinging() { 5234 try { 5235 ITelephony telephony = getITelephony(); 5236 if (telephony != null) 5237 return telephony.isRinging(getOpPackageName()); 5238 } catch (RemoteException e) { 5239 Log.e(TAG, "Error calling ITelephony#isRinging", e); 5240 } 5241 return false; 5242 } 5243 5244 /** @hide */ 5245 @SystemApi 5246 @RequiresPermission(anyOf = { 5247 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 5248 android.Manifest.permission.READ_PHONE_STATE 5249 }) isIdle()5250 public boolean isIdle() { 5251 try { 5252 ITelephony telephony = getITelephony(); 5253 if (telephony != null) 5254 return telephony.isIdle(getOpPackageName()); 5255 } catch (RemoteException e) { 5256 Log.e(TAG, "Error calling ITelephony#isIdle", e); 5257 } 5258 return true; 5259 } 5260 5261 /** @hide */ 5262 @SystemApi 5263 @RequiresPermission(anyOf = { 5264 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 5265 android.Manifest.permission.READ_PHONE_STATE 5266 }) isRadioOn()5267 public boolean isRadioOn() { 5268 try { 5269 ITelephony telephony = getITelephony(); 5270 if (telephony != null) 5271 return telephony.isRadioOn(getOpPackageName()); 5272 } catch (RemoteException e) { 5273 Log.e(TAG, "Error calling ITelephony#isRadioOn", e); 5274 } 5275 return false; 5276 } 5277 5278 /** @hide */ 5279 @SystemApi 5280 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) supplyPin(String pin)5281 public boolean supplyPin(String pin) { 5282 try { 5283 ITelephony telephony = getITelephony(); 5284 if (telephony != null) 5285 return telephony.supplyPin(pin); 5286 } catch (RemoteException e) { 5287 Log.e(TAG, "Error calling ITelephony#supplyPin", e); 5288 } 5289 return false; 5290 } 5291 5292 /** @hide */ 5293 @SystemApi 5294 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) supplyPuk(String puk, String pin)5295 public boolean supplyPuk(String puk, String pin) { 5296 try { 5297 ITelephony telephony = getITelephony(); 5298 if (telephony != null) 5299 return telephony.supplyPuk(puk, pin); 5300 } catch (RemoteException e) { 5301 Log.e(TAG, "Error calling ITelephony#supplyPuk", e); 5302 } 5303 return false; 5304 } 5305 5306 /** @hide */ 5307 @SystemApi 5308 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) supplyPinReportResult(String pin)5309 public int[] supplyPinReportResult(String pin) { 5310 try { 5311 ITelephony telephony = getITelephony(); 5312 if (telephony != null) 5313 return telephony.supplyPinReportResult(pin); 5314 } catch (RemoteException e) { 5315 Log.e(TAG, "Error calling ITelephony#supplyPinReportResult", e); 5316 } 5317 return new int[0]; 5318 } 5319 5320 /** @hide */ 5321 @SystemApi 5322 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) supplyPukReportResult(String puk, String pin)5323 public int[] supplyPukReportResult(String puk, String pin) { 5324 try { 5325 ITelephony telephony = getITelephony(); 5326 if (telephony != null) 5327 return telephony.supplyPukReportResult(puk, pin); 5328 } catch (RemoteException e) { 5329 Log.e(TAG, "Error calling ITelephony#]", e); 5330 } 5331 return new int[0]; 5332 } 5333 5334 /** 5335 * Used to notify callers of 5336 * {@link TelephonyManager#sendUssdRequest(String, UssdResponseCallback, Handler)} when the 5337 * network either successfully executes a USSD request, or if there was a failure while 5338 * executing the request. 5339 * <p> 5340 * {@link #onReceiveUssdResponse(TelephonyManager, String, CharSequence)} will be called if the 5341 * USSD request has succeeded. 5342 * {@link #onReceiveUssdResponseFailed(TelephonyManager, String, int)} will be called if the 5343 * USSD request has failed. 5344 */ 5345 public static abstract class UssdResponseCallback { 5346 /** 5347 * Called when a USSD request has succeeded. The {@code response} contains the USSD 5348 * response received from the network. The calling app can choose to either display the 5349 * response to the user or perform some operation based on the response. 5350 * <p> 5351 * USSD responses are unstructured text and their content is determined by the mobile network 5352 * operator. 5353 * 5354 * @param telephonyManager the TelephonyManager the callback is registered to. 5355 * @param request the USSD request sent to the mobile network. 5356 * @param response the response to the USSD request provided by the mobile network. 5357 **/ onReceiveUssdResponse(final TelephonyManager telephonyManager, String request, CharSequence response)5358 public void onReceiveUssdResponse(final TelephonyManager telephonyManager, 5359 String request, CharSequence response) {}; 5360 5361 /** 5362 * Called when a USSD request has failed to complete. 5363 * 5364 * @param telephonyManager the TelephonyManager the callback is registered to. 5365 * @param request the USSD request sent to the mobile network. 5366 * @param failureCode failure code indicating why the request failed. Will be either 5367 * {@link TelephonyManager#USSD_RETURN_FAILURE} or 5368 * {@link TelephonyManager#USSD_ERROR_SERVICE_UNAVAIL}. 5369 **/ onReceiveUssdResponseFailed(final TelephonyManager telephonyManager, String request, int failureCode)5370 public void onReceiveUssdResponseFailed(final TelephonyManager telephonyManager, 5371 String request, int failureCode) {}; 5372 } 5373 5374 /** 5375 * Sends an Unstructured Supplementary Service Data (USSD) request to the mobile network and 5376 * informs the caller of the response via the supplied {@code callback}. 5377 * <p>Carriers define USSD codes which can be sent by the user to request information such as 5378 * the user's current data balance or minutes balance. 5379 * <p>Requires permission: 5380 * {@link android.Manifest.permission#CALL_PHONE} 5381 * @param ussdRequest the USSD command to be executed. 5382 * @param callback called by the framework to inform the caller of the result of executing the 5383 * USSD request (see {@link UssdResponseCallback}). 5384 * @param handler the {@link Handler} to run the request on. 5385 */ 5386 @RequiresPermission(android.Manifest.permission.CALL_PHONE) sendUssdRequest(String ussdRequest, final UssdResponseCallback callback, Handler handler)5387 public void sendUssdRequest(String ussdRequest, 5388 final UssdResponseCallback callback, Handler handler) { 5389 checkNotNull(callback, "UssdResponseCallback cannot be null."); 5390 final TelephonyManager telephonyManager = this; 5391 5392 ResultReceiver wrappedCallback = new ResultReceiver(handler) { 5393 @Override 5394 protected void onReceiveResult(int resultCode, Bundle ussdResponse) { 5395 Rlog.d(TAG, "USSD:" + resultCode); 5396 checkNotNull(ussdResponse, "ussdResponse cannot be null."); 5397 UssdResponse response = ussdResponse.getParcelable(USSD_RESPONSE); 5398 5399 if (resultCode == USSD_RETURN_SUCCESS) { 5400 callback.onReceiveUssdResponse(telephonyManager, response.getUssdRequest(), 5401 response.getReturnMessage()); 5402 } else { 5403 callback.onReceiveUssdResponseFailed(telephonyManager, 5404 response.getUssdRequest(), resultCode); 5405 } 5406 } 5407 }; 5408 5409 try { 5410 ITelephony telephony = getITelephony(); 5411 if (telephony != null) { 5412 telephony.handleUssdRequest(getSubId(), ussdRequest, wrappedCallback); 5413 } 5414 } catch (RemoteException e) { 5415 Log.e(TAG, "Error calling ITelephony#sendUSSDCode", e); 5416 UssdResponse response = new UssdResponse(ussdRequest, ""); 5417 Bundle returnData = new Bundle(); 5418 returnData.putParcelable(USSD_RESPONSE, response); 5419 wrappedCallback.send(USSD_ERROR_SERVICE_UNAVAIL, returnData); 5420 } 5421 } 5422 5423 /** 5424 * Whether the device is currently on a technology (e.g. UMTS or LTE) which can support 5425 * voice and data simultaneously. This can change based on location or network condition. 5426 * 5427 * @return {@code true} if simultaneous voice and data supported, and {@code false} otherwise. 5428 */ isConcurrentVoiceAndDataSupported()5429 public boolean isConcurrentVoiceAndDataSupported() { 5430 try { 5431 ITelephony telephony = getITelephony(); 5432 return (telephony == null ? false : telephony.isConcurrentVoiceAndDataAllowed( 5433 getSubId())); 5434 } catch (RemoteException e) { 5435 Log.e(TAG, "Error calling ITelephony#isConcurrentVoiceAndDataAllowed", e); 5436 } 5437 return false; 5438 } 5439 5440 /** @hide */ 5441 @SystemApi 5442 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) handlePinMmi(String dialString)5443 public boolean handlePinMmi(String dialString) { 5444 try { 5445 ITelephony telephony = getITelephony(); 5446 if (telephony != null) 5447 return telephony.handlePinMmi(dialString); 5448 } catch (RemoteException e) { 5449 Log.e(TAG, "Error calling ITelephony#handlePinMmi", e); 5450 } 5451 return false; 5452 } 5453 5454 /** @hide */ 5455 @SystemApi 5456 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) handlePinMmiForSubscriber(int subId, String dialString)5457 public boolean handlePinMmiForSubscriber(int subId, String dialString) { 5458 try { 5459 ITelephony telephony = getITelephony(); 5460 if (telephony != null) 5461 return telephony.handlePinMmiForSubscriber(subId, dialString); 5462 } catch (RemoteException e) { 5463 Log.e(TAG, "Error calling ITelephony#handlePinMmi", e); 5464 } 5465 return false; 5466 } 5467 5468 /** @hide */ 5469 @SystemApi 5470 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) toggleRadioOnOff()5471 public void toggleRadioOnOff() { 5472 try { 5473 ITelephony telephony = getITelephony(); 5474 if (telephony != null) 5475 telephony.toggleRadioOnOff(); 5476 } catch (RemoteException e) { 5477 Log.e(TAG, "Error calling ITelephony#toggleRadioOnOff", e); 5478 } 5479 } 5480 5481 /** @hide */ 5482 @SystemApi 5483 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) setRadio(boolean turnOn)5484 public boolean setRadio(boolean turnOn) { 5485 try { 5486 ITelephony telephony = getITelephony(); 5487 if (telephony != null) 5488 return telephony.setRadio(turnOn); 5489 } catch (RemoteException e) { 5490 Log.e(TAG, "Error calling ITelephony#setRadio", e); 5491 } 5492 return false; 5493 } 5494 5495 /** @hide */ 5496 @SystemApi 5497 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) setRadioPower(boolean turnOn)5498 public boolean setRadioPower(boolean turnOn) { 5499 try { 5500 ITelephony telephony = getITelephony(); 5501 if (telephony != null) 5502 return telephony.setRadioPower(turnOn); 5503 } catch (RemoteException e) { 5504 Log.e(TAG, "Error calling ITelephony#setRadioPower", e); 5505 } 5506 return false; 5507 } 5508 5509 /** @hide */ 5510 @SystemApi 5511 @SuppressLint("Doclava125") updateServiceLocation()5512 public void updateServiceLocation() { 5513 try { 5514 ITelephony telephony = getITelephony(); 5515 if (telephony != null) 5516 telephony.updateServiceLocation(); 5517 } catch (RemoteException e) { 5518 Log.e(TAG, "Error calling ITelephony#updateServiceLocation", e); 5519 } 5520 } 5521 5522 /** @hide */ 5523 @SystemApi 5524 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) enableDataConnectivity()5525 public boolean enableDataConnectivity() { 5526 try { 5527 ITelephony telephony = getITelephony(); 5528 if (telephony != null) 5529 return telephony.enableDataConnectivity(); 5530 } catch (RemoteException e) { 5531 Log.e(TAG, "Error calling ITelephony#enableDataConnectivity", e); 5532 } 5533 return false; 5534 } 5535 5536 /** @hide */ 5537 @SystemApi 5538 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) disableDataConnectivity()5539 public boolean disableDataConnectivity() { 5540 try { 5541 ITelephony telephony = getITelephony(); 5542 if (telephony != null) 5543 return telephony.disableDataConnectivity(); 5544 } catch (RemoteException e) { 5545 Log.e(TAG, "Error calling ITelephony#disableDataConnectivity", e); 5546 } 5547 return false; 5548 } 5549 5550 /** @hide */ 5551 @SystemApi isDataConnectivityPossible()5552 public boolean isDataConnectivityPossible() { 5553 try { 5554 ITelephony telephony = getITelephony(); 5555 if (telephony != null) 5556 return telephony.isDataConnectivityPossible(getSubId(SubscriptionManager 5557 .getDefaultDataSubscriptionId())); 5558 } catch (RemoteException e) { 5559 Log.e(TAG, "Error calling ITelephony#isDataAllowed", e); 5560 } 5561 return false; 5562 } 5563 5564 /** @hide */ 5565 @SystemApi needsOtaServiceProvisioning()5566 public boolean needsOtaServiceProvisioning() { 5567 try { 5568 ITelephony telephony = getITelephony(); 5569 if (telephony != null) 5570 return telephony.needsOtaServiceProvisioning(); 5571 } catch (RemoteException e) { 5572 Log.e(TAG, "Error calling ITelephony#needsOtaServiceProvisioning", e); 5573 } 5574 return false; 5575 } 5576 5577 /** 5578 * Turns mobile data on or off. 5579 * If this object has been created with {@link #createForSubscriptionId}, applies to the given 5580 * subId. Otherwise, applies to {@link SubscriptionManager#getDefaultDataSubscriptionId()} 5581 * 5582 * <p>Requires Permission: 5583 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} or that the 5584 * calling app has carrier privileges. 5585 * 5586 * @param enable Whether to enable mobile data. 5587 * 5588 * @see #hasCarrierPrivileges 5589 */ 5590 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) setDataEnabled(boolean enable)5591 public void setDataEnabled(boolean enable) { 5592 setDataEnabled(getSubId(SubscriptionManager.getDefaultDataSubscriptionId()), enable); 5593 } 5594 5595 /** @hide */ 5596 @SystemApi 5597 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) setDataEnabled(int subId, boolean enable)5598 public void setDataEnabled(int subId, boolean enable) { 5599 try { 5600 Log.d(TAG, "setDataEnabled: enabled=" + enable); 5601 ITelephony telephony = getITelephony(); 5602 if (telephony != null) 5603 telephony.setDataEnabled(subId, enable); 5604 } catch (RemoteException e) { 5605 Log.e(TAG, "Error calling ITelephony#setDataEnabled", e); 5606 } 5607 } 5608 5609 5610 /** 5611 * @deprecated use {@link #isDataEnabled()} instead. 5612 * @hide 5613 */ 5614 @SystemApi 5615 @Deprecated getDataEnabled()5616 public boolean getDataEnabled() { 5617 return isDataEnabled(); 5618 } 5619 5620 /** 5621 * Returns whether mobile data is enabled or not. 5622 * 5623 * If this object has been created with {@link #createForSubscriptionId}, applies to the given 5624 * subId. Otherwise, applies to {@link SubscriptionManager#getDefaultDataSubscriptionId()} 5625 * 5626 * <p>Requires one of the following permissions: 5627 * {@link android.Manifest.permission#ACCESS_NETWORK_STATE ACCESS_NETWORK_STATE}, 5628 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}, or that the 5629 * calling app has carrier privileges. 5630 * 5631 * <p>Note that this does not take into account any data restrictions that may be present on the 5632 * calling app. Such restrictions may be inspected with 5633 * {@link ConnectivityManager#getRestrictBackgroundStatus}. 5634 * 5635 * @return true if mobile data is enabled. 5636 * 5637 * @see #hasCarrierPrivileges 5638 */ 5639 @SuppressWarnings("deprecation") isDataEnabled()5640 public boolean isDataEnabled() { 5641 return getDataEnabled(getSubId(SubscriptionManager.getDefaultDataSubscriptionId())); 5642 } 5643 5644 /** 5645 * @deprecated use {@link #isDataEnabled(int)} instead. 5646 * @hide 5647 */ 5648 @SystemApi getDataEnabled(int subId)5649 public boolean getDataEnabled(int subId) { 5650 boolean retVal = false; 5651 try { 5652 ITelephony telephony = getITelephony(); 5653 if (telephony != null) 5654 retVal = telephony.getDataEnabled(subId); 5655 } catch (RemoteException e) { 5656 Log.e(TAG, "Error calling ITelephony#getDataEnabled", e); 5657 } catch (NullPointerException e) { 5658 } 5659 return retVal; 5660 } 5661 5662 /** 5663 * Returns the result and response from RIL for oem request 5664 * 5665 * @param oemReq the data is sent to ril. 5666 * @param oemResp the respose data from RIL. 5667 * @return negative value request was not handled or get error 5668 * 0 request was handled succesfully, but no response data 5669 * positive value success, data length of response 5670 * @hide 5671 * @deprecated OEM needs a vendor-extension hal and their apps should use that instead 5672 */ 5673 @Deprecated invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp)5674 public int invokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp) { 5675 try { 5676 ITelephony telephony = getITelephony(); 5677 if (telephony != null) 5678 return telephony.invokeOemRilRequestRaw(oemReq, oemResp); 5679 } catch (RemoteException ex) { 5680 } catch (NullPointerException ex) { 5681 } 5682 return -1; 5683 } 5684 5685 /** @hide */ 5686 @SystemApi 5687 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) enableVideoCalling(boolean enable)5688 public void enableVideoCalling(boolean enable) { 5689 try { 5690 ITelephony telephony = getITelephony(); 5691 if (telephony != null) 5692 telephony.enableVideoCalling(enable); 5693 } catch (RemoteException e) { 5694 Log.e(TAG, "Error calling ITelephony#enableVideoCalling", e); 5695 } 5696 } 5697 5698 /** @hide */ 5699 @SystemApi 5700 @RequiresPermission(anyOf = { 5701 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 5702 android.Manifest.permission.READ_PHONE_STATE 5703 }) isVideoCallingEnabled()5704 public boolean isVideoCallingEnabled() { 5705 try { 5706 ITelephony telephony = getITelephony(); 5707 if (telephony != null) 5708 return telephony.isVideoCallingEnabled(getOpPackageName()); 5709 } catch (RemoteException e) { 5710 Log.e(TAG, "Error calling ITelephony#isVideoCallingEnabled", e); 5711 } 5712 return false; 5713 } 5714 5715 /** 5716 * Whether the device supports configuring the DTMF tone length. 5717 * 5718 * @return {@code true} if the DTMF tone length can be changed, and {@code false} otherwise. 5719 */ canChangeDtmfToneLength()5720 public boolean canChangeDtmfToneLength() { 5721 try { 5722 ITelephony telephony = getITelephony(); 5723 if (telephony != null) { 5724 return telephony.canChangeDtmfToneLength(); 5725 } 5726 } catch (RemoteException e) { 5727 Log.e(TAG, "Error calling ITelephony#canChangeDtmfToneLength", e); 5728 } catch (SecurityException e) { 5729 Log.e(TAG, "Permission error calling ITelephony#canChangeDtmfToneLength", e); 5730 } 5731 return false; 5732 } 5733 5734 /** 5735 * Whether the device is a world phone. 5736 * 5737 * @return {@code true} if the device is a world phone, and {@code false} otherwise. 5738 */ isWorldPhone()5739 public boolean isWorldPhone() { 5740 try { 5741 ITelephony telephony = getITelephony(); 5742 if (telephony != null) { 5743 return telephony.isWorldPhone(); 5744 } 5745 } catch (RemoteException e) { 5746 Log.e(TAG, "Error calling ITelephony#isWorldPhone", e); 5747 } catch (SecurityException e) { 5748 Log.e(TAG, "Permission error calling ITelephony#isWorldPhone", e); 5749 } 5750 return false; 5751 } 5752 5753 /** 5754 * Whether the phone supports TTY mode. 5755 * 5756 * @return {@code true} if the device supports TTY mode, and {@code false} otherwise. 5757 */ isTtyModeSupported()5758 public boolean isTtyModeSupported() { 5759 try { 5760 ITelephony telephony = getITelephony(); 5761 if (telephony != null) { 5762 return telephony.isTtyModeSupported(); 5763 } 5764 } catch (RemoteException e) { 5765 Log.e(TAG, "Error calling ITelephony#isTtyModeSupported", e); 5766 } catch (SecurityException e) { 5767 Log.e(TAG, "Permission error calling ITelephony#isTtyModeSupported", e); 5768 } 5769 return false; 5770 } 5771 5772 /** 5773 * Whether the phone supports hearing aid compatibility. 5774 * 5775 * @return {@code true} if the device supports hearing aid compatibility, and {@code false} 5776 * otherwise. 5777 */ isHearingAidCompatibilitySupported()5778 public boolean isHearingAidCompatibilitySupported() { 5779 try { 5780 ITelephony telephony = getITelephony(); 5781 if (telephony != null) { 5782 return telephony.isHearingAidCompatibilitySupported(); 5783 } 5784 } catch (RemoteException e) { 5785 Log.e(TAG, "Error calling ITelephony#isHearingAidCompatibilitySupported", e); 5786 } catch (SecurityException e) { 5787 Log.e(TAG, "Permission error calling ITelephony#isHearingAidCompatibilitySupported", e); 5788 } 5789 return false; 5790 } 5791 5792 /** 5793 * This function retrieves value for setting "name+subId", and if that is not found 5794 * retrieves value for setting "name", and if that is not found throws 5795 * SettingNotFoundException 5796 * 5797 * @hide 5798 */ getIntWithSubId(ContentResolver cr, String name, int subId)5799 public static int getIntWithSubId(ContentResolver cr, String name, int subId) 5800 throws SettingNotFoundException { 5801 try { 5802 return Settings.Global.getInt(cr, name + subId); 5803 } catch (SettingNotFoundException e) { 5804 try { 5805 int val = Settings.Global.getInt(cr, name); 5806 Settings.Global.putInt(cr, name + subId, val); 5807 5808 /* We are now moving from 'setting' to 'setting+subId', and using the value stored 5809 * for 'setting' as default. Reset the default (since it may have a user set 5810 * value). */ 5811 int default_val = val; 5812 if (name.equals(Settings.Global.MOBILE_DATA)) { 5813 default_val = "true".equalsIgnoreCase( 5814 SystemProperties.get("ro.com.android.mobiledata", "true")) ? 1 : 0; 5815 } else if (name.equals(Settings.Global.DATA_ROAMING)) { 5816 default_val = "true".equalsIgnoreCase( 5817 SystemProperties.get("ro.com.android.dataroaming", "false")) ? 1 : 0; 5818 } 5819 5820 if (default_val != val) { 5821 Settings.Global.putInt(cr, name, default_val); 5822 } 5823 5824 return val; 5825 } catch (SettingNotFoundException exc) { 5826 throw new SettingNotFoundException(name); 5827 } 5828 } 5829 } 5830 5831 /** 5832 * Returns the IMS Registration Status 5833 * @hide 5834 */ isImsRegistered()5835 public boolean isImsRegistered() { 5836 try { 5837 ITelephony telephony = getITelephony(); 5838 if (telephony == null) 5839 return false; 5840 return telephony.isImsRegistered(); 5841 } catch (RemoteException ex) { 5842 return false; 5843 } catch (NullPointerException ex) { 5844 return false; 5845 } 5846 } 5847 5848 /** 5849 * Returns the Status of Volte 5850 * @hide 5851 */ isVolteAvailable()5852 public boolean isVolteAvailable() { 5853 try { 5854 return getITelephony().isVolteAvailable(); 5855 } catch (RemoteException ex) { 5856 return false; 5857 } catch (NullPointerException ex) { 5858 return false; 5859 } 5860 } 5861 5862 /** 5863 * Returns the Status of video telephony (VT) 5864 * @hide 5865 */ isVideoTelephonyAvailable()5866 public boolean isVideoTelephonyAvailable() { 5867 try { 5868 return getITelephony().isVideoTelephonyAvailable(); 5869 } catch (RemoteException ex) { 5870 return false; 5871 } catch (NullPointerException ex) { 5872 return false; 5873 } 5874 } 5875 5876 /** 5877 * Returns the Status of Wi-Fi Calling 5878 * @hide 5879 */ isWifiCallingAvailable()5880 public boolean isWifiCallingAvailable() { 5881 try { 5882 return getITelephony().isWifiCallingAvailable(); 5883 } catch (RemoteException ex) { 5884 return false; 5885 } catch (NullPointerException ex) { 5886 return false; 5887 } 5888 } 5889 5890 /** 5891 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the default phone. 5892 * 5893 * @hide 5894 */ setSimOperatorNumeric(String numeric)5895 public void setSimOperatorNumeric(String numeric) { 5896 int phoneId = getPhoneId(); 5897 setSimOperatorNumericForPhone(phoneId, numeric); 5898 } 5899 5900 /** 5901 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the given phone. 5902 * 5903 * @hide 5904 */ setSimOperatorNumericForPhone(int phoneId, String numeric)5905 public void setSimOperatorNumericForPhone(int phoneId, String numeric) { 5906 setTelephonyProperty(phoneId, 5907 TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, numeric); 5908 } 5909 5910 /** 5911 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the default phone. 5912 * 5913 * @hide 5914 */ setSimOperatorName(String name)5915 public void setSimOperatorName(String name) { 5916 int phoneId = getPhoneId(); 5917 setSimOperatorNameForPhone(phoneId, name); 5918 } 5919 5920 /** 5921 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the given phone. 5922 * 5923 * @hide 5924 */ setSimOperatorNameForPhone(int phoneId, String name)5925 public void setSimOperatorNameForPhone(int phoneId, String name) { 5926 setTelephonyProperty(phoneId, 5927 TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, name); 5928 } 5929 5930 /** 5931 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY for the default phone. 5932 * 5933 * @hide 5934 */ setSimCountryIso(String iso)5935 public void setSimCountryIso(String iso) { 5936 int phoneId = getPhoneId(); 5937 setSimCountryIsoForPhone(phoneId, iso); 5938 } 5939 5940 /** 5941 * Set TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY for the given phone. 5942 * 5943 * @hide 5944 */ setSimCountryIsoForPhone(int phoneId, String iso)5945 public void setSimCountryIsoForPhone(int phoneId, String iso) { 5946 setTelephonyProperty(phoneId, 5947 TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY, iso); 5948 } 5949 5950 /** 5951 * Set TelephonyProperties.PROPERTY_SIM_STATE for the default phone. 5952 * 5953 * @hide 5954 */ setSimState(String state)5955 public void setSimState(String state) { 5956 int phoneId = getPhoneId(); 5957 setSimStateForPhone(phoneId, state); 5958 } 5959 5960 /** 5961 * Set TelephonyProperties.PROPERTY_SIM_STATE for the given phone. 5962 * 5963 * @hide 5964 */ setSimStateForPhone(int phoneId, String state)5965 public void setSimStateForPhone(int phoneId, String state) { 5966 setTelephonyProperty(phoneId, 5967 TelephonyProperties.PROPERTY_SIM_STATE, state); 5968 } 5969 5970 /** 5971 * Requested state of SIM 5972 * 5973 * CARD_POWER_DOWN 5974 * Powers down the SIM. SIM must be up prior. 5975 * 5976 * CARD_POWER_UP 5977 * Powers up the SIM normally. SIM must be down prior. 5978 * 5979 * CARD_POWER_UP_PASS_THROUGH 5980 * Powers up the SIM in PASS_THROUGH mode. SIM must be down prior. 5981 * When SIM is powered up in PASS_THOUGH mode, the modem does not send 5982 * any command to it (for example SELECT of MF, or TERMINAL CAPABILITY), 5983 * and the SIM card is controlled completely by Telephony sending APDUs 5984 * directly. The SIM card state will be RIL_CARDSTATE_PRESENT and the 5985 * number of card apps will be 0. 5986 * No new error code is generated. Emergency calls are supported in the 5987 * same way as if the SIM card is absent. 5988 * The PASS_THROUGH mode is valid only for the specific card session where it 5989 * is activated, and normal behavior occurs at the next SIM initialization, 5990 * unless PASS_THROUGH mode is requested again. Hence, the last power-up mode 5991 * is NOT persistent across boots. On reboot, SIM will power up normally. 5992 */ 5993 /** @hide */ 5994 public static final int CARD_POWER_DOWN = 0; 5995 /** @hide */ 5996 public static final int CARD_POWER_UP = 1; 5997 /** @hide */ 5998 public static final int CARD_POWER_UP_PASS_THROUGH = 2; 5999 6000 /** 6001 * Set SIM card power state. 6002 * 6003 * @param state State of SIM (power down, power up, pass through) 6004 * @see #CARD_POWER_DOWN 6005 * @see #CARD_POWER_UP 6006 * @see #CARD_POWER_UP_PASS_THROUGH 6007 * Callers should monitor for {@link TelephonyIntents#ACTION_SIM_STATE_CHANGED} 6008 * broadcasts to determine success or failure and timeout if needed. 6009 * 6010 * <p>Requires Permission: 6011 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 6012 * 6013 * @hide 6014 **/ setSimPowerState(int state)6015 public void setSimPowerState(int state) { 6016 setSimPowerStateForSlot(getSlotIndex(), state); 6017 } 6018 6019 /** 6020 * Set SIM card power state. 6021 * 6022 * @param slotIndex SIM slot id 6023 * @param state State of SIM (power down, power up, pass through) 6024 * @see #CARD_POWER_DOWN 6025 * @see #CARD_POWER_UP 6026 * @see #CARD_POWER_UP_PASS_THROUGH 6027 * Callers should monitor for {@link TelephonyIntents#ACTION_SIM_STATE_CHANGED} 6028 * broadcasts to determine success or failure and timeout if needed. 6029 * 6030 * <p>Requires Permission: 6031 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 6032 * 6033 * @hide 6034 **/ setSimPowerStateForSlot(int slotIndex, int state)6035 public void setSimPowerStateForSlot(int slotIndex, int state) { 6036 try { 6037 ITelephony telephony = getITelephony(); 6038 if (telephony != null) { 6039 telephony.setSimPowerStateForSlot(slotIndex, state); 6040 } 6041 } catch (RemoteException e) { 6042 Log.e(TAG, "Error calling ITelephony#setSimPowerStateForSlot", e); 6043 } catch (SecurityException e) { 6044 Log.e(TAG, "Permission error calling ITelephony#setSimPowerStateForSlot", e); 6045 } 6046 } 6047 6048 /** 6049 * Set baseband version for the default phone. 6050 * 6051 * @param version baseband version 6052 * @hide 6053 */ setBasebandVersion(String version)6054 public void setBasebandVersion(String version) { 6055 int phoneId = getPhoneId(); 6056 setBasebandVersionForPhone(phoneId, version); 6057 } 6058 6059 /** 6060 * Set baseband version by phone id. 6061 * 6062 * @param phoneId for which baseband version is set 6063 * @param version baseband version 6064 * @hide 6065 */ setBasebandVersionForPhone(int phoneId, String version)6066 public void setBasebandVersionForPhone(int phoneId, String version) { 6067 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6068 String prop = TelephonyProperties.PROPERTY_BASEBAND_VERSION + 6069 ((phoneId == 0) ? "" : Integer.toString(phoneId)); 6070 SystemProperties.set(prop, version); 6071 } 6072 } 6073 6074 /** 6075 * Set phone type for the default phone. 6076 * 6077 * @param type phone type 6078 * 6079 * @hide 6080 */ setPhoneType(int type)6081 public void setPhoneType(int type) { 6082 int phoneId = getPhoneId(); 6083 setPhoneType(phoneId, type); 6084 } 6085 6086 /** 6087 * Set phone type by phone id. 6088 * 6089 * @param phoneId for which phone type is set 6090 * @param type phone type 6091 * 6092 * @hide 6093 */ setPhoneType(int phoneId, int type)6094 public void setPhoneType(int phoneId, int type) { 6095 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6096 TelephonyManager.setTelephonyProperty(phoneId, 6097 TelephonyProperties.CURRENT_ACTIVE_PHONE, String.valueOf(type)); 6098 } 6099 } 6100 6101 /** 6102 * Get OTASP number schema for the default phone. 6103 * 6104 * @param defaultValue default value 6105 * @return OTA SP number schema 6106 * 6107 * @hide 6108 */ getOtaSpNumberSchema(String defaultValue)6109 public String getOtaSpNumberSchema(String defaultValue) { 6110 int phoneId = getPhoneId(); 6111 return getOtaSpNumberSchemaForPhone(phoneId, defaultValue); 6112 } 6113 6114 /** 6115 * Get OTASP number schema by phone id. 6116 * 6117 * @param phoneId for which OTA SP number schema is get 6118 * @param defaultValue default value 6119 * @return OTA SP number schema 6120 * 6121 * @hide 6122 */ getOtaSpNumberSchemaForPhone(int phoneId, String defaultValue)6123 public String getOtaSpNumberSchemaForPhone(int phoneId, String defaultValue) { 6124 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6125 return TelephonyManager.getTelephonyProperty(phoneId, 6126 TelephonyProperties.PROPERTY_OTASP_NUM_SCHEMA, defaultValue); 6127 } 6128 6129 return defaultValue; 6130 } 6131 6132 /** 6133 * Get SMS receive capable from system property for the default phone. 6134 * 6135 * @param defaultValue default value 6136 * @return SMS receive capable 6137 * 6138 * @hide 6139 */ getSmsReceiveCapable(boolean defaultValue)6140 public boolean getSmsReceiveCapable(boolean defaultValue) { 6141 int phoneId = getPhoneId(); 6142 return getSmsReceiveCapableForPhone(phoneId, defaultValue); 6143 } 6144 6145 /** 6146 * Get SMS receive capable from system property by phone id. 6147 * 6148 * @param phoneId for which SMS receive capable is get 6149 * @param defaultValue default value 6150 * @return SMS receive capable 6151 * 6152 * @hide 6153 */ getSmsReceiveCapableForPhone(int phoneId, boolean defaultValue)6154 public boolean getSmsReceiveCapableForPhone(int phoneId, boolean defaultValue) { 6155 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6156 return Boolean.parseBoolean(TelephonyManager.getTelephonyProperty(phoneId, 6157 TelephonyProperties.PROPERTY_SMS_RECEIVE, String.valueOf(defaultValue))); 6158 } 6159 6160 return defaultValue; 6161 } 6162 6163 /** 6164 * Get SMS send capable from system property for the default phone. 6165 * 6166 * @param defaultValue default value 6167 * @return SMS send capable 6168 * 6169 * @hide 6170 */ getSmsSendCapable(boolean defaultValue)6171 public boolean getSmsSendCapable(boolean defaultValue) { 6172 int phoneId = getPhoneId(); 6173 return getSmsSendCapableForPhone(phoneId, defaultValue); 6174 } 6175 6176 /** 6177 * Get SMS send capable from system property by phone id. 6178 * 6179 * @param phoneId for which SMS send capable is get 6180 * @param defaultValue default value 6181 * @return SMS send capable 6182 * 6183 * @hide 6184 */ getSmsSendCapableForPhone(int phoneId, boolean defaultValue)6185 public boolean getSmsSendCapableForPhone(int phoneId, boolean defaultValue) { 6186 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6187 return Boolean.parseBoolean(TelephonyManager.getTelephonyProperty(phoneId, 6188 TelephonyProperties.PROPERTY_SMS_SEND, String.valueOf(defaultValue))); 6189 } 6190 6191 return defaultValue; 6192 } 6193 6194 /** 6195 * Set the alphabetic name of current registered operator. 6196 * @param name the alphabetic name of current registered operator. 6197 * @hide 6198 */ setNetworkOperatorName(String name)6199 public void setNetworkOperatorName(String name) { 6200 int phoneId = getPhoneId(); 6201 setNetworkOperatorNameForPhone(phoneId, name); 6202 } 6203 6204 /** 6205 * Set the alphabetic name of current registered operator. 6206 * @param phoneId which phone you want to set 6207 * @param name the alphabetic name of current registered operator. 6208 * @hide 6209 */ setNetworkOperatorNameForPhone(int phoneId, String name)6210 public void setNetworkOperatorNameForPhone(int phoneId, String name) { 6211 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6212 setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ALPHA, name); 6213 } 6214 } 6215 6216 /** 6217 * Set the numeric name (MCC+MNC) of current registered operator. 6218 * @param operator the numeric name (MCC+MNC) of current registered operator 6219 * @hide 6220 */ setNetworkOperatorNumeric(String numeric)6221 public void setNetworkOperatorNumeric(String numeric) { 6222 int phoneId = getPhoneId(); 6223 setNetworkOperatorNumericForPhone(phoneId, numeric); 6224 } 6225 6226 /** 6227 * Set the numeric name (MCC+MNC) of current registered operator. 6228 * @param phoneId for which phone type is set 6229 * @param operator the numeric name (MCC+MNC) of current registered operator 6230 * @hide 6231 */ setNetworkOperatorNumericForPhone(int phoneId, String numeric)6232 public void setNetworkOperatorNumericForPhone(int phoneId, String numeric) { 6233 setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, numeric); 6234 } 6235 6236 /** 6237 * Set roaming state of the current network, for GSM purposes. 6238 * @param isRoaming is network in romaing state or not 6239 * @hide 6240 */ setNetworkRoaming(boolean isRoaming)6241 public void setNetworkRoaming(boolean isRoaming) { 6242 int phoneId = getPhoneId(); 6243 setNetworkRoamingForPhone(phoneId, isRoaming); 6244 } 6245 6246 /** 6247 * Set roaming state of the current network, for GSM purposes. 6248 * @param phoneId which phone you want to set 6249 * @param isRoaming is network in romaing state or not 6250 * @hide 6251 */ setNetworkRoamingForPhone(int phoneId, boolean isRoaming)6252 public void setNetworkRoamingForPhone(int phoneId, boolean isRoaming) { 6253 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6254 setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ISROAMING, 6255 isRoaming ? "true" : "false"); 6256 } 6257 } 6258 6259 /** 6260 * Set the ISO country code equivalent of the current registered 6261 * operator's MCC (Mobile Country Code). 6262 * @param iso the ISO country code equivalent of the current registered 6263 * @hide 6264 */ setNetworkCountryIso(String iso)6265 public void setNetworkCountryIso(String iso) { 6266 int phoneId = getPhoneId(); 6267 setNetworkCountryIsoForPhone(phoneId, iso); 6268 } 6269 6270 /** 6271 * Set the ISO country code equivalent of the current registered 6272 * operator's MCC (Mobile Country Code). 6273 * @param phoneId which phone you want to set 6274 * @param iso the ISO country code equivalent of the current registered 6275 * @hide 6276 */ setNetworkCountryIsoForPhone(int phoneId, String iso)6277 public void setNetworkCountryIsoForPhone(int phoneId, String iso) { 6278 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6279 setTelephonyProperty(phoneId, 6280 TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, iso); 6281 } 6282 } 6283 6284 /** 6285 * Set the network type currently in use on the device for data transmission. 6286 * 6287 * If this object has been created with {@link #createForSubscriptionId}, applies to the 6288 * phoneId associated with the given subId. Otherwise, applies to the phoneId associated with 6289 * {@link SubscriptionManager#getDefaultDataSubscriptionId()} 6290 * @param type the network type currently in use on the device for data transmission 6291 * @hide 6292 */ setDataNetworkType(int type)6293 public void setDataNetworkType(int type) { 6294 int phoneId = getPhoneId(SubscriptionManager.getDefaultDataSubscriptionId()); 6295 setDataNetworkTypeForPhone(phoneId, type); 6296 } 6297 6298 /** 6299 * Set the network type currently in use on the device for data transmission. 6300 * @param phoneId which phone you want to set 6301 * @param type the network type currently in use on the device for data transmission 6302 * @hide 6303 */ setDataNetworkTypeForPhone(int phoneId, int type)6304 public void setDataNetworkTypeForPhone(int phoneId, int type) { 6305 if (SubscriptionManager.isValidPhoneId(phoneId)) { 6306 setTelephonyProperty(phoneId, 6307 TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, 6308 ServiceState.rilRadioTechnologyToString(type)); 6309 } 6310 } 6311 6312 /** 6313 * Returns the subscription ID for the given phone account. 6314 * @hide 6315 */ getSubIdForPhoneAccount(PhoneAccount phoneAccount)6316 public int getSubIdForPhoneAccount(PhoneAccount phoneAccount) { 6317 int retval = SubscriptionManager.INVALID_SUBSCRIPTION_ID; 6318 try { 6319 ITelephony service = getITelephony(); 6320 if (service != null) { 6321 retval = service.getSubIdForPhoneAccount(phoneAccount); 6322 } 6323 } catch (RemoteException e) { 6324 } 6325 6326 return retval; 6327 } 6328 getSubIdForPhoneAccountHandle(PhoneAccountHandle phoneAccountHandle)6329 private int getSubIdForPhoneAccountHandle(PhoneAccountHandle phoneAccountHandle) { 6330 int retval = SubscriptionManager.INVALID_SUBSCRIPTION_ID; 6331 try { 6332 ITelecomService service = getTelecomService(); 6333 if (service != null) { 6334 retval = getSubIdForPhoneAccount(service.getPhoneAccount(phoneAccountHandle)); 6335 } 6336 } catch (RemoteException e) { 6337 } 6338 6339 return retval; 6340 } 6341 6342 /** 6343 * Resets telephony manager settings back to factory defaults. 6344 * 6345 * @hide 6346 */ factoryReset(int subId)6347 public void factoryReset(int subId) { 6348 try { 6349 Log.d(TAG, "factoryReset: subId=" + subId); 6350 ITelephony telephony = getITelephony(); 6351 if (telephony != null) 6352 telephony.factoryReset(subId); 6353 } catch (RemoteException e) { 6354 } 6355 } 6356 6357 6358 /** @hide */ getLocaleFromDefaultSim()6359 public String getLocaleFromDefaultSim() { 6360 try { 6361 final ITelephony telephony = getITelephony(); 6362 if (telephony != null) { 6363 return telephony.getLocaleFromDefaultSim(); 6364 } 6365 } catch (RemoteException ex) { 6366 } 6367 return null; 6368 } 6369 6370 /** 6371 * Requests the modem activity info. The recipient will place the result 6372 * in `result`. 6373 * @param result The object on which the recipient will send the resulting 6374 * {@link android.telephony.ModemActivityInfo} object. 6375 * @hide 6376 */ requestModemActivityInfo(ResultReceiver result)6377 public void requestModemActivityInfo(ResultReceiver result) { 6378 try { 6379 ITelephony service = getITelephony(); 6380 if (service != null) { 6381 service.requestModemActivityInfo(result); 6382 return; 6383 } 6384 } catch (RemoteException e) { 6385 Log.e(TAG, "Error calling ITelephony#getModemActivityInfo", e); 6386 } 6387 result.send(0, null); 6388 } 6389 6390 /** 6391 * Returns the current {@link ServiceState} information. 6392 */ 6393 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getServiceState()6394 public ServiceState getServiceState() { 6395 return getServiceStateForSubscriber(getSubId()); 6396 } 6397 6398 /** 6399 * Returns the service state information on specified subscription. Callers require 6400 * either READ_PRIVILEGED_PHONE_STATE or READ_PHONE_STATE to retrieve the information. 6401 * @hide 6402 */ getServiceStateForSubscriber(int subId)6403 public ServiceState getServiceStateForSubscriber(int subId) { 6404 try { 6405 ITelephony service = getITelephony(); 6406 if (service != null) { 6407 return service.getServiceStateForSubscriber(subId, getOpPackageName()); 6408 } 6409 } catch (RemoteException e) { 6410 Log.e(TAG, "Error calling ITelephony#getServiceStateForSubscriber", e); 6411 } 6412 return null; 6413 } 6414 6415 /** 6416 * Returns the URI for the per-account voicemail ringtone set in Phone settings. 6417 * 6418 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the 6419 * voicemail ringtone. 6420 * @return The URI for the ringtone to play when receiving a voicemail from a specific 6421 * PhoneAccount. 6422 */ getVoicemailRingtoneUri(PhoneAccountHandle accountHandle)6423 public Uri getVoicemailRingtoneUri(PhoneAccountHandle accountHandle) { 6424 try { 6425 ITelephony service = getITelephony(); 6426 if (service != null) { 6427 return service.getVoicemailRingtoneUri(accountHandle); 6428 } 6429 } catch (RemoteException e) { 6430 Log.e(TAG, "Error calling ITelephony#getVoicemailRingtoneUri", e); 6431 } 6432 return null; 6433 } 6434 6435 /** 6436 * Sets the per-account voicemail ringtone. 6437 * 6438 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or has 6439 * permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}. 6440 * 6441 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the 6442 * voicemail ringtone. 6443 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific 6444 * PhoneAccount. 6445 * @see #hasCarrierPrivileges 6446 */ setVoicemailRingtoneUri(PhoneAccountHandle phoneAccountHandle, Uri uri)6447 public void setVoicemailRingtoneUri(PhoneAccountHandle phoneAccountHandle, Uri uri) { 6448 try { 6449 ITelephony service = getITelephony(); 6450 if (service != null) { 6451 service.setVoicemailRingtoneUri(getOpPackageName(), phoneAccountHandle, uri); 6452 } 6453 } catch (RemoteException e) { 6454 Log.e(TAG, "Error calling ITelephony#setVoicemailRingtoneUri", e); 6455 } 6456 } 6457 6458 /** 6459 * Returns whether vibration is set for voicemail notification in Phone settings. 6460 * 6461 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the 6462 * voicemail vibration setting. 6463 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise. 6464 */ isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle)6465 public boolean isVoicemailVibrationEnabled(PhoneAccountHandle accountHandle) { 6466 try { 6467 ITelephony service = getITelephony(); 6468 if (service != null) { 6469 return service.isVoicemailVibrationEnabled(accountHandle); 6470 } 6471 } catch (RemoteException e) { 6472 Log.e(TAG, "Error calling ITelephony#isVoicemailVibrationEnabled", e); 6473 } 6474 return false; 6475 } 6476 6477 /** 6478 * Sets the per-account preference whether vibration is enabled for voicemail notifications. 6479 * 6480 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or has 6481 * permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}. 6482 * 6483 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the 6484 * voicemail vibration setting. 6485 * @param enabled Whether to enable or disable vibration for voicemail notifications from a 6486 * specific PhoneAccount. 6487 * @see #hasCarrierPrivileges 6488 */ setVoicemailVibrationEnabled(PhoneAccountHandle phoneAccountHandle, boolean enabled)6489 public void setVoicemailVibrationEnabled(PhoneAccountHandle phoneAccountHandle, 6490 boolean enabled) { 6491 try { 6492 ITelephony service = getITelephony(); 6493 if (service != null) { 6494 service.setVoicemailVibrationEnabled(getOpPackageName(), phoneAccountHandle, 6495 enabled); 6496 } 6497 } catch (RemoteException e) { 6498 Log.e(TAG, "Error calling ITelephony#isVoicemailVibrationEnabled", e); 6499 } 6500 } 6501 6502 /** 6503 * Return the application ID for the app type like {@link APPTYPE_CSIM}. 6504 * 6505 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6506 * 6507 * @param appType the uicc app type like {@link APPTYPE_CSIM} 6508 * @return Application ID for specificied app type or null if no uicc or error. 6509 * @hide 6510 */ getAidForAppType(int appType)6511 public String getAidForAppType(int appType) { 6512 return getAidForAppType(getSubId(), appType); 6513 } 6514 6515 /** 6516 * Return the application ID for the app type like {@link APPTYPE_CSIM}. 6517 * 6518 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6519 * 6520 * @param subId the subscription ID that this request applies to. 6521 * @param appType the uicc app type, like {@link APPTYPE_CSIM} 6522 * @return Application ID for specificied app type or null if no uicc or error. 6523 * @hide 6524 */ getAidForAppType(int subId, int appType)6525 public String getAidForAppType(int subId, int appType) { 6526 try { 6527 ITelephony service = getITelephony(); 6528 if (service != null) { 6529 return service.getAidForAppType(subId, appType); 6530 } 6531 } catch (RemoteException e) { 6532 Log.e(TAG, "Error calling ITelephony#getAidForAppType", e); 6533 } 6534 return null; 6535 } 6536 6537 /** 6538 * Return the Electronic Serial Number. 6539 * 6540 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6541 * 6542 * @return ESN or null if error. 6543 * @hide 6544 */ getEsn()6545 public String getEsn() { 6546 return getEsn(getSubId()); 6547 } 6548 6549 /** 6550 * Return the Electronic Serial Number. 6551 * 6552 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6553 * 6554 * @param subId the subscription ID that this request applies to. 6555 * @return ESN or null if error. 6556 * @hide 6557 */ getEsn(int subId)6558 public String getEsn(int subId) { 6559 try { 6560 ITelephony service = getITelephony(); 6561 if (service != null) { 6562 return service.getEsn(subId); 6563 } 6564 } catch (RemoteException e) { 6565 Log.e(TAG, "Error calling ITelephony#getEsn", e); 6566 } 6567 return null; 6568 } 6569 6570 /** 6571 * Return the Preferred Roaming List Version 6572 * 6573 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6574 * 6575 * @return PRLVersion or null if error. 6576 * @hide 6577 */ getCdmaPrlVersion()6578 public String getCdmaPrlVersion() { 6579 return getCdmaPrlVersion(getSubId()); 6580 } 6581 6582 /** 6583 * Return the Preferred Roaming List Version 6584 * 6585 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 6586 * 6587 * @param subId the subscription ID that this request applies to. 6588 * @return PRLVersion or null if error. 6589 * @hide 6590 */ getCdmaPrlVersion(int subId)6591 public String getCdmaPrlVersion(int subId) { 6592 try { 6593 ITelephony service = getITelephony(); 6594 if (service != null) { 6595 return service.getCdmaPrlVersion(subId); 6596 } 6597 } catch (RemoteException e) { 6598 Log.e(TAG, "Error calling ITelephony#getCdmaPrlVersion", e); 6599 } 6600 return null; 6601 } 6602 6603 /** 6604 * Get snapshot of Telephony histograms 6605 * @return List of Telephony histograms 6606 * Requires Permission: 6607 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 6608 * Or the calling app has carrier privileges. 6609 * @hide 6610 */ 6611 @SystemApi 6612 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getTelephonyHistograms()6613 public List<TelephonyHistogram> getTelephonyHistograms() { 6614 try { 6615 ITelephony service = getITelephony(); 6616 if (service != null) { 6617 return service.getTelephonyHistograms(); 6618 } 6619 } catch (RemoteException e) { 6620 Log.e(TAG, "Error calling ITelephony#getTelephonyHistograms", e); 6621 } 6622 return null; 6623 } 6624 6625 /** 6626 * Set the allowed carrier list for slotIndex 6627 * Require system privileges. In the future we may add this to carrier APIs. 6628 * 6629 * <p>Requires Permission: 6630 * {@link android.Manifest.permission#MODIFY_PHONE_STATE} 6631 * 6632 * <p>This method works only on devices with {@link 6633 * android.content.pm.PackageManager#FEATURE_TELEPHONY_CARRIERLOCK} enabled. 6634 * 6635 * @return The number of carriers set successfully. Should be length of 6636 * carrierList on success; -1 if carrierList null or on error. 6637 * @hide 6638 */ 6639 @SystemApi 6640 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) setAllowedCarriers(int slotIndex, List<CarrierIdentifier> carriers)6641 public int setAllowedCarriers(int slotIndex, List<CarrierIdentifier> carriers) { 6642 try { 6643 ITelephony service = getITelephony(); 6644 if (service != null) { 6645 return service.setAllowedCarriers(slotIndex, carriers); 6646 } 6647 } catch (RemoteException e) { 6648 Log.e(TAG, "Error calling ITelephony#setAllowedCarriers", e); 6649 } catch (NullPointerException e) { 6650 Log.e(TAG, "Error calling ITelephony#setAllowedCarriers", e); 6651 } 6652 return -1; 6653 } 6654 6655 /** 6656 * Get the allowed carrier list for slotIndex. 6657 * Require system privileges. In the future we may add this to carrier APIs. 6658 * 6659 * <p>This method returns valid data on devices with {@link 6660 * android.content.pm.PackageManager#FEATURE_TELEPHONY_CARRIERLOCK} enabled. 6661 * 6662 * @return List of {@link android.telephony.CarrierIdentifier}; empty list 6663 * means all carriers are allowed. 6664 * @hide 6665 */ 6666 @SystemApi 6667 @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) getAllowedCarriers(int slotIndex)6668 public List<CarrierIdentifier> getAllowedCarriers(int slotIndex) { 6669 try { 6670 ITelephony service = getITelephony(); 6671 if (service != null) { 6672 return service.getAllowedCarriers(slotIndex); 6673 } 6674 } catch (RemoteException e) { 6675 Log.e(TAG, "Error calling ITelephony#getAllowedCarriers", e); 6676 } catch (NullPointerException e) { 6677 Log.e(TAG, "Error calling ITelephony#getAllowedCarriers", e); 6678 } 6679 return new ArrayList<CarrierIdentifier>(0); 6680 } 6681 6682 /** 6683 * Action set from carrier signalling broadcast receivers to enable/disable metered apns 6684 * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required 6685 * @param subId the subscription ID that this action applies to. 6686 * @param enabled control enable or disable metered apns. 6687 * @hide 6688 */ carrierActionSetMeteredApnsEnabled(int subId, boolean enabled)6689 public void carrierActionSetMeteredApnsEnabled(int subId, boolean enabled) { 6690 try { 6691 ITelephony service = getITelephony(); 6692 if (service != null) { 6693 service.carrierActionSetMeteredApnsEnabled(subId, enabled); 6694 } 6695 } catch (RemoteException e) { 6696 Log.e(TAG, "Error calling ITelephony#carrierActionSetMeteredApnsEnabled", e); 6697 } 6698 } 6699 6700 /** 6701 * Action set from carrier signalling broadcast receivers to enable/disable radio 6702 * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required 6703 * @param subId the subscription ID that this action applies to. 6704 * @param enabled control enable or disable radio. 6705 * @hide 6706 */ carrierActionSetRadioEnabled(int subId, boolean enabled)6707 public void carrierActionSetRadioEnabled(int subId, boolean enabled) { 6708 try { 6709 ITelephony service = getITelephony(); 6710 if (service != null) { 6711 service.carrierActionSetRadioEnabled(subId, enabled); 6712 } 6713 } catch (RemoteException e) { 6714 Log.e(TAG, "Error calling ITelephony#carrierActionSetRadioEnabled", e); 6715 } 6716 } 6717 6718 /** 6719 * Action set from carrier signalling broadcast receivers to start/stop reporting default 6720 * network available events 6721 * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required 6722 * @param subId the subscription ID that this action applies to. 6723 * @param report control start/stop reporting network status. 6724 * @hide 6725 */ carrierActionReportDefaultNetworkStatus(int subId, boolean report)6726 public void carrierActionReportDefaultNetworkStatus(int subId, boolean report) { 6727 try { 6728 ITelephony service = getITelephony(); 6729 if (service != null) { 6730 service.carrierActionReportDefaultNetworkStatus(subId, report); 6731 } 6732 } catch (RemoteException e) { 6733 Log.e(TAG, "Error calling ITelephony#carrierActionReportDefaultNetworkStatus", e); 6734 } 6735 } 6736 6737 /** 6738 * Get aggregated video call data usage since boot. 6739 * Permissions android.Manifest.permission.READ_NETWORK_USAGE_HISTORY is required. 6740 * 6741 * @param how one of the NetworkStats.STATS_PER_* constants depending on whether the request is 6742 * for data usage per uid or overall usage. 6743 * @return Snapshot of video call data usage 6744 * @hide 6745 */ getVtDataUsage(int how)6746 public NetworkStats getVtDataUsage(int how) { 6747 boolean perUidStats = (how == NetworkStats.STATS_PER_UID); 6748 try { 6749 ITelephony service = getITelephony(); 6750 if (service != null) { 6751 return service.getVtDataUsage(getSubId(), perUidStats); 6752 } 6753 } catch (RemoteException e) { 6754 Log.e(TAG, "Error calling ITelephony#getVtDataUsage", e); 6755 } 6756 return null; 6757 } 6758 6759 /** 6760 * Policy control of data connection. Usually used when data limit is passed. 6761 * @param enabled True if enabling the data, otherwise disabling. 6762 * @param subId sub id 6763 * @hide 6764 */ setPolicyDataEnabled(boolean enabled, int subId)6765 public void setPolicyDataEnabled(boolean enabled, int subId) { 6766 try { 6767 ITelephony service = getITelephony(); 6768 if (service != null) { 6769 service.setPolicyDataEnabled(enabled, subId); 6770 } 6771 } catch (RemoteException e) { 6772 Log.e(TAG, "Error calling ITelephony#setPolicyDataEnabled", e); 6773 } 6774 } 6775 6776 /** 6777 * Get Client request stats which will contain statistical information 6778 * on each request made by client. 6779 * Callers require either READ_PRIVILEGED_PHONE_STATE or 6780 * READ_PHONE_STATE to retrieve the information. 6781 * @param subId sub id 6782 * @return List of Client Request Stats 6783 * @hide 6784 */ getClientRequestStats(int subId)6785 public List<ClientRequestStats> getClientRequestStats(int subId) { 6786 try { 6787 ITelephony service = getITelephony(); 6788 if (service != null) { 6789 return service.getClientRequestStats(getOpPackageName(), subId); 6790 } 6791 } catch (RemoteException e) { 6792 Log.e(TAG, "Error calling ITelephony#getClientRequestStats", e); 6793 } 6794 6795 return null; 6796 } 6797 6798 /** 6799 * Check if phone is in emergency callback mode 6800 * @return true if phone is in emergency callback mode 6801 * @hide 6802 */ getEmergencyCallbackMode()6803 public boolean getEmergencyCallbackMode() { 6804 return getEmergencyCallbackMode(getSubId()); 6805 } 6806 6807 /** 6808 * Check if phone is in emergency callback mode 6809 * @return true if phone is in emergency callback mode 6810 * @param subId the subscription ID that this action applies to. 6811 * @hide 6812 */ getEmergencyCallbackMode(int subId)6813 public boolean getEmergencyCallbackMode(int subId) { 6814 try { 6815 ITelephony telephony = getITelephony(); 6816 if (telephony == null) { 6817 return false; 6818 } 6819 return telephony.getEmergencyCallbackMode(subId); 6820 } catch (RemoteException e) { 6821 Log.e(TAG, "Error calling ITelephony#getEmergencyCallbackMode", e); 6822 } 6823 return false; 6824 } 6825 6826 /** 6827 * Get the most recently available signal strength information. 6828 * 6829 * Get the most recent SignalStrength information reported by the modem. Due 6830 * to power saving this information may not always be current. 6831 * @return the most recent cached signal strength info from the modem 6832 * @hide 6833 */ 6834 @Nullable getSignalStrength()6835 public SignalStrength getSignalStrength() { 6836 try { 6837 ITelephony service = getITelephony(); 6838 if (service != null) { 6839 return service.getSignalStrength(getSubId()); 6840 } 6841 } catch (RemoteException e) { 6842 Log.e(TAG, "Error calling ITelephony#getSignalStrength", e); 6843 } 6844 return null; 6845 } 6846 } 6847