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 */ 165 public TelephonyManager(Context context) { 166 this(context, SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 167 } 168 169 /** @hide */ 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 */ 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 */ 191 public static TelephonyManager getDefault() { 192 return sInstance; 193 } 194 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} */ 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 */ 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} */ 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 */ 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 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} */ 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) 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) 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) 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) 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) 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) 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) 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) 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}*/ 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}*/ 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 }) 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) 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) 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) 1209 public void disableLocationUpdates() { 1210 disableLocationUpdates(getSubId()); 1211 } 1212 1213 /** @hide */ 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) 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 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 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 */ 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 */ 1330 public int getPhoneType() { 1331 if (!isVoiceCapable()) { 1332 return PHONE_TYPE_NONE; 1333 } 1334 return getCurrentPhoneType(); 1335 } 1336 1337 private int getPhoneTypeFromProperty() { 1338 return getPhoneTypeFromProperty(getPhoneId()); 1339 } 1340 1341 /** {@hide} */ 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 1351 private int getPhoneTypeFromNetworkType() { 1352 return getPhoneTypeFromNetworkType(getPhoneId()); 1353 } 1354 1355 /** {@hide} */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 **/ 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 */ 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) 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 */ 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 */ 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 */ 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 */ 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} */ 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 */ 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) 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) 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) 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) 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) 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 */ 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 */ 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} */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) 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) 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) 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) 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) 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) 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 */ 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 */ 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 */ 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 its always separated from encrypted 2450 * permanent identity with ,. Key identifier AVP is presented in ASCII string 2451 * with name=value format. 2452 * @hide 2453 */ 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) 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) 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 }) 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 }) 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 */ 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 */ 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) 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) 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 */ 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) 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) 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) 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) 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) 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) 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 */ 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 */ 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") 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") 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 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) 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 */ 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 */ 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 */ 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 */ 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 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 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) 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 */ 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 */ 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) 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) 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) 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) 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) 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) 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 3491 private ITelephony getITelephony() { 3492 return ITelephony.Stub.asInterface(ServiceManager.getService(Context.TELEPHONY_SERVICE)); 3493 } 3494 3495 /** 3496 * @hide 3497 */ 3498 private ITelecomService getTelecomService() { 3499 return ITelecomService.Stub.asInterface(ServiceManager.getService(Context.TELECOM_SERVICE)); 3500 } 3501 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 */ 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) 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) 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) 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) 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) 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) 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 */ 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 */ 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) 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) 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) 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); 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) 5035 public String getCdmaMdn() { 5036 return getCdmaMdn(getSubId()); 5037 } 5038 5039 /** @hide */ 5040 @SystemApi 5041 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 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) 5058 public String getCdmaMin() { 5059 return getCdmaMin(getSubId()); 5060 } 5061 5062 /** @hide */ 5063 @SystemApi 5064 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 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") 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") 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 5112 public List<String> getCarrierPackageNamesForIntent(Intent intent) { 5113 return getCarrierPackageNamesForIntentAndPhone(intent, getPhoneId()); 5114 } 5115 5116 /** @hide */ 5117 @SystemApi 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 */ 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") 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) 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) 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) 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") 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 }) 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 }) 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 }) 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 }) 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) 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) 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) 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) 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 **/ 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 **/ 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) 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 */ 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) 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) 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) 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) 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) 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") 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) 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) 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 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 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) 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) 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 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") 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 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 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) 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 }) 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 **/ 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 **/ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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) 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) 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) 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) 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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
