ITelephony.aidl revision 1210f41f59a131b50e4d54f308e7d1acbe76cbea
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.internal.telephony; 18 19import android.app.PendingIntent; 20import android.content.Intent; 21import android.os.Bundle; 22import android.os.ResultReceiver; 23import android.net.Uri; 24import android.service.carrier.CarrierIdentifier; 25import android.telecom.PhoneAccount; 26import android.telecom.PhoneAccountHandle; 27import android.telephony.CellInfo; 28import android.telephony.ClientRequestStats; 29import android.telephony.IccOpenLogicalChannelResponse; 30import android.telephony.ModemActivityInfo; 31import android.telephony.NeighboringCellInfo; 32import android.telephony.RadioAccessFamily; 33import android.telephony.ServiceState; 34import android.telephony.TelephonyHistogram; 35import android.telephony.VisualVoicemailSmsFilterSettings; 36import com.android.ims.internal.IImsServiceController; 37import com.android.ims.internal.IImsServiceFeatureListener; 38import com.android.internal.telephony.CellNetworkScanResult; 39import com.android.internal.telephony.OperatorInfo; 40 41import java.util.List; 42 43 44/** 45 * Interface used to interact with the phone. Mostly this is used by the 46 * TelephonyManager class. A few places are still using this directly. 47 * Please clean them up if possible and use TelephonyManager instead. 48 * 49 * {@hide} 50 */ 51interface ITelephony { 52 53 /** 54 * Dial a number. This doesn't place the call. It displays 55 * the Dialer screen. 56 * @param number the number to be dialed. If null, this 57 * would display the Dialer screen with no number pre-filled. 58 */ 59 void dial(String number); 60 61 /** 62 * Place a call to the specified number. 63 * @param callingPackage The package making the call. 64 * @param number the number to be called. 65 */ 66 void call(String callingPackage, String number); 67 68 /** 69 * End call if there is a call in progress, otherwise does nothing. 70 * 71 * @return whether it hung up 72 */ 73 boolean endCall(); 74 75 /** 76 * End call on particular subId or go to the Home screen 77 * @param subId user preferred subId. 78 * @return whether it hung up 79 */ 80 boolean endCallForSubscriber(int subId); 81 82 /** 83 * Answer the currently-ringing call. 84 * 85 * If there's already a current active call, that call will be 86 * automatically put on hold. If both lines are currently in use, the 87 * current active call will be ended. 88 * 89 * TODO: provide a flag to let the caller specify what policy to use 90 * if both lines are in use. (The current behavior is hardwired to 91 * "answer incoming, end ongoing", which is how the CALL button 92 * is specced to behave.) 93 * 94 * TODO: this should be a oneway call (especially since it's called 95 * directly from the key queue thread). 96 */ 97 void answerRingingCall(); 98 99 /** 100 * Answer the currently-ringing call on particular subId . 101 * 102 * If there's already a current active call, that call will be 103 * automatically put on hold. If both lines are currently in use, the 104 * current active call will be ended. 105 * 106 * TODO: provide a flag to let the caller specify what policy to use 107 * if both lines are in use. (The current behavior is hardwired to 108 * "answer incoming, end ongoing", which is how the CALL button 109 * is specced to behave.) 110 * 111 * TODO: this should be a oneway call (especially since it's called 112 * directly from the key queue thread). 113 */ 114 void answerRingingCallForSubscriber(int subId); 115 116 /** 117 * Silence the ringer if an incoming call is currently ringing. 118 * (If vibrating, stop the vibrator also.) 119 * 120 * It's safe to call this if the ringer has already been silenced, or 121 * even if there's no incoming call. (If so, this method will do nothing.) 122 * 123 * TODO: this should be a oneway call too (see above). 124 * (Actually *all* the methods here that return void can 125 * probably be oneway.) 126 */ 127 void silenceRinger(); 128 129 /** 130 * Check if we are in either an active or holding call 131 * @param callingPackage the name of the package making the call. 132 * @return true if the phone state is OFFHOOK. 133 */ 134 boolean isOffhook(String callingPackage); 135 136 /** 137 * Check if a particular subId has an active or holding call 138 * 139 * @param subId user preferred subId. 140 * @param callingPackage the name of the package making the call. 141 * @return true if the phone state is OFFHOOK. 142 */ 143 boolean isOffhookForSubscriber(int subId, String callingPackage); 144 145 /** 146 * Check if an incoming phone call is ringing or call waiting 147 * on a particular subId. 148 * 149 * @param subId user preferred subId. 150 * @param callingPackage the name of the package making the call. 151 * @return true if the phone state is RINGING. 152 */ 153 boolean isRingingForSubscriber(int subId, String callingPackage); 154 155 /** 156 * Check if an incoming phone call is ringing or call waiting. 157 * @param callingPackage the name of the package making the call. 158 * @return true if the phone state is RINGING. 159 */ 160 boolean isRinging(String callingPackage); 161 162 /** 163 * Check if the phone is idle. 164 * @param callingPackage the name of the package making the call. 165 * @return true if the phone state is IDLE. 166 */ 167 boolean isIdle(String callingPackage); 168 169 /** 170 * Check if the phone is idle on a particular subId. 171 * 172 * @param subId user preferred subId. 173 * @param callingPackage the name of the package making the call. 174 * @return true if the phone state is IDLE. 175 */ 176 boolean isIdleForSubscriber(int subId, String callingPackage); 177 178 /** 179 * Check to see if the radio is on or not. 180 * @param callingPackage the name of the package making the call. 181 * @return returns true if the radio is on. 182 */ 183 boolean isRadioOn(String callingPackage); 184 185 /** 186 * Check to see if the radio is on or not on particular subId. 187 * @param subId user preferred subId. 188 * @param callingPackage the name of the package making the call. 189 * @return returns true if the radio is on. 190 */ 191 boolean isRadioOnForSubscriber(int subId, String callingPackage); 192 193 /** 194 * Supply a pin to unlock the SIM. Blocks until a result is determined. 195 * @param pin The pin to check. 196 * @return whether the operation was a success. 197 */ 198 boolean supplyPin(String pin); 199 200 /** 201 * Supply a pin to unlock the SIM for particular subId. 202 * Blocks until a result is determined. 203 * @param pin The pin to check. 204 * @param subId user preferred subId. 205 * @return whether the operation was a success. 206 */ 207 boolean supplyPinForSubscriber(int subId, String pin); 208 209 /** 210 * Supply puk to unlock the SIM and set SIM pin to new pin. 211 * Blocks until a result is determined. 212 * @param puk The puk to check. 213 * pin The new pin to be set in SIM 214 * @return whether the operation was a success. 215 */ 216 boolean supplyPuk(String puk, String pin); 217 218 /** 219 * Supply puk to unlock the SIM and set SIM pin to new pin. 220 * Blocks until a result is determined. 221 * @param puk The puk to check. 222 * pin The new pin to be set in SIM 223 * @param subId user preferred subId. 224 * @return whether the operation was a success. 225 */ 226 boolean supplyPukForSubscriber(int subId, String puk, String pin); 227 228 /** 229 * Supply a pin to unlock the SIM. Blocks until a result is determined. 230 * Returns a specific success/error code. 231 * @param pin The pin to check. 232 * @return retValue[0] = Phone.PIN_RESULT_SUCCESS on success. Otherwise error code 233 * retValue[1] = number of attempts remaining if known otherwise -1 234 */ 235 int[] supplyPinReportResult(String pin); 236 237 /** 238 * Supply a pin to unlock the SIM. Blocks until a result is determined. 239 * Returns a specific success/error code. 240 * @param pin The pin to check. 241 * @return retValue[0] = Phone.PIN_RESULT_SUCCESS on success. Otherwise error code 242 * retValue[1] = number of attempts remaining if known otherwise -1 243 */ 244 int[] supplyPinReportResultForSubscriber(int subId, String pin); 245 246 /** 247 * Supply puk to unlock the SIM and set SIM pin to new pin. 248 * Blocks until a result is determined. 249 * Returns a specific success/error code 250 * @param puk The puk to check 251 * pin The pin to check. 252 * @return retValue[0] = Phone.PIN_RESULT_SUCCESS on success. Otherwise error code 253 * retValue[1] = number of attempts remaining if known otherwise -1 254 */ 255 int[] supplyPukReportResult(String puk, String pin); 256 257 /** 258 * Supply puk to unlock the SIM and set SIM pin to new pin. 259 * Blocks until a result is determined. 260 * Returns a specific success/error code 261 * @param puk The puk to check 262 * pin The pin to check. 263 * @return retValue[0] = Phone.PIN_RESULT_SUCCESS on success. Otherwise error code 264 * retValue[1] = number of attempts remaining if known otherwise -1 265 */ 266 int[] supplyPukReportResultForSubscriber(int subId, String puk, String pin); 267 268 /** 269 * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated 270 * without SEND (so <code>dial</code> is not appropriate). 271 * 272 * @param dialString the MMI command to be executed. 273 * @return true if MMI command is executed. 274 */ 275 boolean handlePinMmi(String dialString); 276 277 278 /** 279 * Handles USSD commands. 280 * 281 * @param subId The subscription to use. 282 * @param ussdRequest the USSD command to be executed. 283 * @param wrappedCallback receives a callback result. 284 */ 285 void handleUssdRequest(int subId, String ussdRequest, in ResultReceiver wrappedCallback); 286 287 /** 288 * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated 289 * without SEND (so <code>dial</code> is not appropriate) for 290 * a particular subId. 291 * @param dialString the MMI command to be executed. 292 * @param subId user preferred subId. 293 * @return true if MMI command is executed. 294 */ 295 boolean handlePinMmiForSubscriber(int subId, String dialString); 296 297 /** 298 * Toggles the radio on or off. 299 */ 300 void toggleRadioOnOff(); 301 302 /** 303 * Toggles the radio on or off on particular subId. 304 * @param subId user preferred subId. 305 */ 306 void toggleRadioOnOffForSubscriber(int subId); 307 308 /** 309 * Set the radio to on or off 310 */ 311 boolean setRadio(boolean turnOn); 312 313 /** 314 * Set the radio to on or off on particular subId. 315 * @param subId user preferred subId. 316 */ 317 boolean setRadioForSubscriber(int subId, boolean turnOn); 318 319 /** 320 * Set the radio to on or off unconditionally 321 */ 322 boolean setRadioPower(boolean turnOn); 323 324 /** 325 * Request to update location information in service state 326 */ 327 void updateServiceLocation(); 328 329 /** 330 * Request to update location information for a subscrition in service state 331 * @param subId user preferred subId. 332 */ 333 void updateServiceLocationForSubscriber(int subId); 334 335 /** 336 * Enable location update notifications. 337 */ 338 void enableLocationUpdates(); 339 340 /** 341 * Enable location update notifications. 342 * @param subId user preferred subId. 343 */ 344 void enableLocationUpdatesForSubscriber(int subId); 345 346 /** 347 * Disable location update notifications. 348 */ 349 void disableLocationUpdates(); 350 351 /** 352 * Disable location update notifications. 353 * @param subId user preferred subId. 354 */ 355 void disableLocationUpdatesForSubscriber(int subId); 356 357 /** 358 * Allow mobile data connections. 359 */ 360 boolean enableDataConnectivity(); 361 362 /** 363 * Disallow mobile data connections. 364 */ 365 boolean disableDataConnectivity(); 366 367 /** 368 * Report whether data connectivity is possible. 369 */ 370 boolean isDataConnectivityPossible(); 371 372 Bundle getCellLocation(String callingPkg); 373 374 /** 375 * Returns the neighboring cell information of the device. 376 */ 377 List<NeighboringCellInfo> getNeighboringCellInfo(String callingPkg); 378 379 int getCallState(); 380 381 /** 382 * Returns the call state for a slot. 383 */ 384 int getCallStateForSlot(int slotIndex); 385 386 int getDataActivity(); 387 int getDataState(); 388 389 /** 390 * Returns the current active phone type as integer. 391 * Returns TelephonyManager.PHONE_TYPE_CDMA if RILConstants.CDMA_PHONE 392 * and TelephonyManager.PHONE_TYPE_GSM if RILConstants.GSM_PHONE 393 */ 394 int getActivePhoneType(); 395 396 /** 397 * Returns the current active phone type as integer for particular slot. 398 * Returns TelephonyManager.PHONE_TYPE_CDMA if RILConstants.CDMA_PHONE 399 * and TelephonyManager.PHONE_TYPE_GSM if RILConstants.GSM_PHONE 400 * @param slotIndex - slot to query. 401 */ 402 int getActivePhoneTypeForSlot(int slotIndex); 403 404 /** 405 * Returns the CDMA ERI icon index to display 406 * @param callingPackage package making the call. 407 */ 408 int getCdmaEriIconIndex(String callingPackage); 409 410 /** 411 * Returns the CDMA ERI icon index to display on particular subId. 412 * @param subId user preferred subId. 413 * @param callingPackage package making the call. 414 */ 415 int getCdmaEriIconIndexForSubscriber(int subId, String callingPackage); 416 417 /** 418 * Returns the CDMA ERI icon mode, 419 * 0 - ON 420 * 1 - FLASHING 421 * @param callingPackage package making the call. 422 */ 423 int getCdmaEriIconMode(String callingPackage); 424 425 /** 426 * Returns the CDMA ERI icon mode on particular subId, 427 * 0 - ON 428 * 1 - FLASHING 429 * @param subId user preferred subId. 430 * @param callingPackage package making the call. 431 */ 432 int getCdmaEriIconModeForSubscriber(int subId, String callingPackage); 433 434 /** 435 * Returns the CDMA ERI text, 436 * @param callingPackage package making the call. 437 */ 438 String getCdmaEriText(String callingPackage); 439 440 /** 441 * Returns the CDMA ERI text for particular subId, 442 * @param subId user preferred subId. 443 * @param callingPackage package making the call. 444 */ 445 String getCdmaEriTextForSubscriber(int subId, String callingPackage); 446 447 /** 448 * Returns true if OTA service provisioning needs to run. 449 * Only relevant on some technologies, others will always 450 * return false. 451 */ 452 boolean needsOtaServiceProvisioning(); 453 454 /** 455 * Sets the voicemail number for a particular subscriber. 456 */ 457 boolean setVoiceMailNumber(int subId, String alphaTag, String number); 458 459 /** 460 * Sets the voice activation state for a particular subscriber. 461 */ 462 void setVoiceActivationState(int subId, int activationState); 463 464 /** 465 * Sets the data activation state for a particular subscriber. 466 */ 467 void setDataActivationState(int subId, int activationState); 468 469 /** 470 * Returns the voice activation state for a particular subscriber. 471 * @param subId user preferred sub 472 * @param callingPackage package queries voice activation state 473 */ 474 int getVoiceActivationState(int subId, String callingPackage); 475 476 /** 477 * Returns the data activation state for a particular subscriber. 478 * @param subId user preferred sub 479 * @param callingPackage package queris data activation state 480 */ 481 int getDataActivationState(int subId, String callingPackage); 482 483 /** 484 * Returns the unread count of voicemails 485 */ 486 int getVoiceMessageCount(); 487 488 /** 489 * Returns the unread count of voicemails for a subId. 490 * @param subId user preferred subId. 491 * Returns the unread count of voicemails 492 */ 493 int getVoiceMessageCountForSubscriber(int subId); 494 495 /** 496 * Returns true if current state supports both voice and data 497 * simultaneously. This can change based on location or network condition. 498 */ 499 boolean isConcurrentVoiceAndDataAllowed(int subId); 500 501 Bundle getVisualVoicemailSettings(String callingPackage, int subId); 502 503 String getVisualVoicemailPackageName(String callingPackage, int subId); 504 505 // Not oneway, caller needs to make sure the vaule is set before receiving a SMS 506 void enableVisualVoicemailSmsFilter(String callingPackage, int subId, 507 in VisualVoicemailSmsFilterSettings settings); 508 509 oneway void disableVisualVoicemailSmsFilter(String callingPackage, int subId); 510 511 // Get settings set by the calling package 512 VisualVoicemailSmsFilterSettings getVisualVoicemailSmsFilterSettings(String callingPackage, 513 int subId); 514 515 /** 516 * Get settings set by the current default dialer, Internal use only. 517 * Requires READ_PRIVILEGED_PHONE_STATE permission. 518 */ 519 VisualVoicemailSmsFilterSettings getActiveVisualVoicemailSmsFilterSettings(int subId); 520 521 /** 522 * Send a visual voicemail SMS. Internal use only. 523 * Requires caller to be the default dialer and have SEND_SMS permission 524 */ 525 void sendVisualVoicemailSmsForSubscriber(in String callingPackage, in int subId, 526 in String number, in int port, in String text, in PendingIntent sentIntent); 527 528 // Send the special dialer code. The IPC caller must be the current default dialer. 529 void sendDialerSpecialCode(String callingPackageName, String inputCode); 530 531 /** 532 * Returns the network type for data transmission 533 * Legacy call, permission-free 534 */ 535 int getNetworkType(); 536 537 /** 538 * Returns the network type of a subId. 539 * @param subId user preferred subId. 540 * @param callingPackage package making the call. 541 */ 542 int getNetworkTypeForSubscriber(int subId, String callingPackage); 543 544 /** 545 * Returns the network type for data transmission 546 * @param callingPackage package making the call. 547 */ 548 int getDataNetworkType(String callingPackage); 549 550 /** 551 * Returns the data network type of a subId 552 * @param subId user preferred subId. 553 * @param callingPackage package making the call. 554 */ 555 int getDataNetworkTypeForSubscriber(int subId, String callingPackage); 556 557 /** 558 * Returns the voice network type of a subId 559 * @param subId user preferred subId. 560 * @param callingPackage package making the call. 561 * Returns the network type 562 */ 563 int getVoiceNetworkTypeForSubscriber(int subId, String callingPackage); 564 565 /** 566 * Return true if an ICC card is present 567 */ 568 boolean hasIccCard(); 569 570 /** 571 * Return true if an ICC card is present for a subId. 572 * @param slotIndex user preferred slotIndex. 573 * Return true if an ICC card is present 574 */ 575 boolean hasIccCardUsingSlotIndex(int slotIndex); 576 577 /** 578 * Return if the current radio is LTE on CDMA. This 579 * is a tri-state return value as for a period of time 580 * the mode may be unknown. 581 * 582 * @param callingPackage the name of the calling package 583 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE} 584 * or {@link PHone#LTE_ON_CDMA_TRUE} 585 */ 586 int getLteOnCdmaMode(String callingPackage); 587 588 /** 589 * Return if the current radio is LTE on CDMA. This 590 * is a tri-state return value as for a period of time 591 * the mode may be unknown. 592 * 593 * @param callingPackage the name of the calling package 594 * @return {@link Phone#LTE_ON_CDMA_UNKNOWN}, {@link Phone#LTE_ON_CDMA_FALSE} 595 * or {@link PHone#LTE_ON_CDMA_TRUE} 596 */ 597 int getLteOnCdmaModeForSubscriber(int subId, String callingPackage); 598 599 /** 600 * Returns the all observed cell information of the device. 601 */ 602 List<CellInfo> getAllCellInfo(String callingPkg); 603 604 /** 605 * Sets minimum time in milli-seconds between onCellInfoChanged 606 */ 607 void setCellInfoListRate(int rateInMillis); 608 609 /** 610 * get default sim 611 * @return sim id 612 */ 613 int getDefaultSim(); 614 615 /** 616 * Opens a logical channel to the ICC card. 617 * 618 * Input parameters equivalent to TS 27.007 AT+CCHO command. 619 * 620 * @param subId The subscription to use. 621 * @param AID Application id. See ETSI 102.221 and 101.220. 622 * @param p2 P2 parameter (described in ISO 7816-4). 623 * @return an IccOpenLogicalChannelResponse object. 624 */ 625 IccOpenLogicalChannelResponse iccOpenLogicalChannel(int subId, String AID, int p2); 626 627 /** 628 * Closes a previously opened logical channel to the ICC card. 629 * 630 * Input parameters equivalent to TS 27.007 AT+CCHC command. 631 * 632 * @param subId The subscription to use. 633 * @param channel is the channel id to be closed as retruned by a 634 * successful iccOpenLogicalChannel. 635 * @return true if the channel was closed successfully. 636 */ 637 boolean iccCloseLogicalChannel(int subId, int channel); 638 639 /** 640 * Transmit an APDU to the ICC card over a logical channel. 641 * 642 * Input parameters equivalent to TS 27.007 AT+CGLA command. 643 * 644 * @param subId The subscription to use. 645 * @param channel is the channel id to be closed as retruned by a 646 * successful iccOpenLogicalChannel. 647 * @param cla Class of the APDU command. 648 * @param instruction Instruction of the APDU command. 649 * @param p1 P1 value of the APDU command. 650 * @param p2 P2 value of the APDU command. 651 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 652 * is sent to the SIM. 653 * @param data Data to be sent with the APDU. 654 * @return The APDU response from the ICC card with the status appended at 655 * the end. 656 */ 657 String iccTransmitApduLogicalChannel(int subId, int channel, int cla, int instruction, 658 int p1, int p2, int p3, String data); 659 660 /** 661 * Transmit an APDU to the ICC card over the basic channel. 662 * 663 * Input parameters equivalent to TS 27.007 AT+CSIM command. 664 * 665 * @param subId The subscription to use. 666 * @param cla Class of the APDU command. 667 * @param instruction Instruction of the APDU command. 668 * @param p1 P1 value of the APDU command. 669 * @param p2 P2 value of the APDU command. 670 * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU 671 * is sent to the SIM. 672 * @param data Data to be sent with the APDU. 673 * @return The APDU response from the ICC card with the status appended at 674 * the end. 675 */ 676 String iccTransmitApduBasicChannel(int subId, int cla, int instruction, 677 int p1, int p2, int p3, String data); 678 679 /** 680 * Returns the response APDU for a command APDU sent through SIM_IO. 681 * 682 * @param subId The subscription to use. 683 * @param fileID 684 * @param command 685 * @param p1 P1 value of the APDU command. 686 * @param p2 P2 value of the APDU command. 687 * @param p3 P3 value of the APDU command. 688 * @param filePath 689 * @return The APDU response. 690 */ 691 byte[] iccExchangeSimIO(int subId, int fileID, int command, int p1, int p2, int p3, 692 String filePath); 693 694 /** 695 * Send ENVELOPE to the SIM and returns the response. 696 * 697 * @param subId The subscription to use. 698 * @param contents String containing SAT/USAT response in hexadecimal 699 * format starting with command tag. See TS 102 223 for 700 * details. 701 * @return The APDU response from the ICC card, with the last 4 bytes 702 * being the status word. If the command fails, returns an empty 703 * string. 704 */ 705 String sendEnvelopeWithStatus(int subId, String content); 706 707 /** 708 * Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}. 709 * Used for device configuration by some CDMA operators. 710 * 711 * @param itemID the ID of the item to read. 712 * @return the NV item as a String, or null on any failure. 713 */ 714 String nvReadItem(int itemID); 715 716 /** 717 * Write one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}. 718 * Used for device configuration by some CDMA operators. 719 * 720 * @param itemID the ID of the item to read. 721 * @param itemValue the value to write, as a String. 722 * @return true on success; false on any failure. 723 */ 724 boolean nvWriteItem(int itemID, String itemValue); 725 726 /** 727 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage. 728 * Used for device configuration by some CDMA operators. 729 * 730 * @param preferredRoamingList byte array containing the new PRL. 731 * @return true on success; false on any failure. 732 */ 733 boolean nvWriteCdmaPrl(in byte[] preferredRoamingList); 734 735 /** 736 * Perform the specified type of NV config reset. The radio will be taken offline 737 * and the device must be rebooted after the operation. Used for device 738 * configuration by some CDMA operators. 739 * 740 * @param resetType the type of reset to perform (1 == factory reset; 2 == NV-only reset). 741 * @return true on success; false on any failure. 742 */ 743 boolean nvResetConfig(int resetType); 744 745 /* 746 * Get the calculated preferred network type. 747 * Used for device configuration by some CDMA operators. 748 * @param callingPackage The package making the call. 749 * 750 * @return the calculated preferred network type, defined in RILConstants.java. 751 */ 752 int getCalculatedPreferredNetworkType(String callingPackage); 753 754 /* 755 * Get the preferred network type. 756 * Used for device configuration by some CDMA operators. 757 * 758 * @param subId the id of the subscription to query. 759 * @return the preferred network type, defined in RILConstants.java. 760 */ 761 int getPreferredNetworkType(int subId); 762 763 /** 764 * Check TETHER_DUN_REQUIRED and TETHER_DUN_APN settings, net.tethering.noprovisioning 765 * SystemProperty, and config_tether_apndata to decide whether DUN APN is required for 766 * tethering. 767 * 768 * @return 0: Not required. 1: required. 2: Not set. 769 */ 770 int getTetherApnRequired(); 771 772 /** 773 * Get ImsServiceController binder from ImsResolver that corresponds to the subId and feature 774 * requested as well as registering the ImsServiceController for callbacks using the 775 * IImsServiceFeatureListener interface. 776 */ 777 IImsServiceController getImsServiceControllerAndListen(int slotIndex, int feature, 778 IImsServiceFeatureListener callback); 779 780 /** 781 * Set the network selection mode to automatic. 782 * 783 * @param subId the id of the subscription to update. 784 */ 785 void setNetworkSelectionModeAutomatic(int subId); 786 787 /** 788 * Perform a radio scan and return the list of avialble networks. 789 * 790 * @param subId the id of the subscription. 791 * @return CellNetworkScanResult containing status of scan and networks. 792 */ 793 CellNetworkScanResult getCellNetworkScanResults(int subId); 794 795 /** 796 * Ask the radio to connect to the input network and change selection mode to manual. 797 * 798 * @param subId the id of the subscription. 799 * @param operatorInfo the operator to attach to. 800 * @param persistSelection should the selection persist till reboot or its 801 * turned off? Will also result in notification being not shown to 802 * the user if the signal is lost. 803 * @return true if the request suceeded. 804 */ 805 boolean setNetworkSelectionModeManual(int subId, in OperatorInfo operator, 806 boolean persistSelection); 807 808 /** 809 * Set the preferred network type. 810 * Used for device configuration by some CDMA operators. 811 * 812 * @param subId the id of the subscription to update. 813 * @param networkType the preferred network type, defined in RILConstants.java. 814 * @return true on success; false on any failure. 815 */ 816 boolean setPreferredNetworkType(int subId, int networkType); 817 818 /** 819 * User enable/disable Mobile Data. 820 * 821 * @param enable true to turn on, else false 822 */ 823 void setDataEnabled(int subId, boolean enable); 824 825 /** 826 * Get the user enabled state of Mobile Data. 827 * 828 * @return true on enabled 829 */ 830 boolean getDataEnabled(int subId); 831 832 /** 833 * Get P-CSCF address from PCO after data connection is established or modified. 834 * @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN 835 * @param callingPackage The package making the call. 836 */ 837 String[] getPcscfAddress(String apnType, String callingPackage); 838 839 /** 840 * Set IMS registration state 841 */ 842 void setImsRegistrationState(boolean registered); 843 844 /** 845 * Return MDN string for CDMA phone. 846 * @param subId user preferred subId. 847 */ 848 String getCdmaMdn(int subId); 849 850 /** 851 * Return MIN string for CDMA phone. 852 * @param subId user preferred subId. 853 */ 854 String getCdmaMin(int subId); 855 856 /** 857 * Has the calling application been granted special privileges by the carrier. 858 * 859 * If any of the packages in the calling UID has carrier privileges, the 860 * call will return true. This access is granted by the owner of the UICC 861 * card and does not depend on the registered carrier. 862 * 863 * TODO: Add a link to documentation. 864 * 865 * @param subId The subscription to use. 866 * @return carrier privilege status defined in TelephonyManager. 867 */ 868 int getCarrierPrivilegeStatus(int subId); 869 870 /** 871 * Similar to above, but check for the package whose name is pkgName. 872 */ 873 int checkCarrierPrivilegesForPackage(String pkgName); 874 875 /** 876 * Similar to above, but check across all phones. 877 */ 878 int checkCarrierPrivilegesForPackageAnyPhone(String pkgName); 879 880 /** 881 * Returns list of the package names of the carrier apps that should handle the input intent 882 * and have carrier privileges for the given phoneId. 883 * 884 * @param intent Intent that will be sent. 885 * @param phoneId The phoneId on which the carrier app has carrier privileges. 886 * @return list of carrier app package names that can handle the intent on phoneId. 887 * Returns null if there is an error and an empty list if there 888 * are no matching packages. 889 */ 890 List<String> getCarrierPackageNamesForIntentAndPhone(in Intent intent, int phoneId); 891 892 /** 893 * Set the line 1 phone number string and its alphatag for the current ICCID 894 * for display purpose only, for example, displayed in Phone Status. It won't 895 * change the actual MSISDN/MDN. To unset alphatag or number, pass in a null 896 * value. 897 * 898 * @param subId the subscriber that the alphatag and dialing number belongs to. 899 * @param alphaTag alpha-tagging of the dailing nubmer 900 * @param number The dialing number 901 * @return true if the operation was executed correctly. 902 */ 903 boolean setLine1NumberForDisplayForSubscriber(int subId, String alphaTag, String number); 904 905 /** 906 * Returns the displayed dialing number string if it was set previously via 907 * {@link #setLine1NumberForDisplay}. Otherwise returns null. 908 * 909 * @param subId whose dialing number for line 1 is returned. 910 * @param callingPackage The package making the call. 911 * @return the displayed dialing number if set, or null if not set. 912 */ 913 String getLine1NumberForDisplay(int subId, String callingPackage); 914 915 /** 916 * Returns the displayed alphatag of the dialing number if it was set 917 * previously via {@link #setLine1NumberForDisplay}. Otherwise returns null. 918 * 919 * @param subId whose alphatag associated with line 1 is returned. 920 * @param callingPackage The package making the call. 921 * @return the displayed alphatag of the dialing number if set, or null if 922 * not set. 923 */ 924 String getLine1AlphaTagForDisplay(int subId, String callingPackage); 925 926 String[] getMergedSubscriberIds(String callingPackage); 927 928 /** 929 * Override the operator branding for the current ICCID. 930 * 931 * Once set, whenever the SIM is present in the device, the service 932 * provider name (SPN) and the operator name will both be replaced by the 933 * brand value input. To unset the value, the same function should be 934 * called with a null brand value. 935 * 936 * <p>Requires Permission: 937 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 938 * or has to be carrier app - see #hasCarrierPrivileges. 939 * 940 * @param subId The subscription to use. 941 * @param brand The brand name to display/set. 942 * @return true if the operation was executed correctly. 943 */ 944 boolean setOperatorBrandOverride(int subId, String brand); 945 946 /** 947 * Override the roaming indicator for the current ICCID. 948 * 949 * Using this call, the carrier app (see #hasCarrierPrivileges) can override 950 * the platform's notion of a network operator being considered roaming or not. 951 * The change only affects the ICCID that was active when this call was made. 952 * 953 * If null is passed as any of the input, the corresponding value is deleted. 954 * 955 * <p>Requires that the caller have carrier privilege. See #hasCarrierPrivileges. 956 * 957 * @param subId for which the roaming overrides apply. 958 * @param gsmRoamingList - List of MCCMNCs to be considered roaming for 3GPP RATs. 959 * @param gsmNonRoamingList - List of MCCMNCs to be considered not roaming for 3GPP RATs. 960 * @param cdmaRoamingList - List of SIDs to be considered roaming for 3GPP2 RATs. 961 * @param cdmaNonRoamingList - List of SIDs to be considered not roaming for 3GPP2 RATs. 962 * @return true if the operation was executed correctly. 963 */ 964 boolean setRoamingOverride(int subId, in List<String> gsmRoamingList, 965 in List<String> gsmNonRoamingList, in List<String> cdmaRoamingList, 966 in List<String> cdmaNonRoamingList); 967 968 /** 969 * Returns the result and response from RIL for oem request 970 * 971 * @param oemReq the data is sent to ril. 972 * @param oemResp the respose data from RIL. 973 * @return negative value request was not handled or get error 974 * 0 request was handled succesfully, but no response data 975 * positive value success, data length of response 976 */ 977 int invokeOemRilRequestRaw(in byte[] oemReq, out byte[] oemResp); 978 979 /** 980 * Check if any mobile Radios need to be shutdown. 981 * 982 * @return true is any mobile radio needs to be shutdown 983 */ 984 boolean needMobileRadioShutdown(); 985 986 /** 987 * Shutdown Mobile Radios 988 */ 989 void shutdownMobileRadios(); 990 991 /** 992 * Set phone radio type and access technology. 993 * 994 * @param rafs an RadioAccessFamily array to indicate all phone's 995 * new radio access family. The length of RadioAccessFamily 996 * must equ]]al to phone count. 997 */ 998 void setRadioCapability(in RadioAccessFamily[] rafs); 999 1000 /** 1001 * Get phone radio type and access technology. 1002 * 1003 * @param phoneId which phone you want to get 1004 * @param callingPackage the name of the package making the call 1005 * @return phone radio type and access technology 1006 */ 1007 int getRadioAccessFamily(in int phoneId, String callingPackage); 1008 1009 /** 1010 * Enables or disables video calling. 1011 * 1012 * @param enable Whether to enable video calling. 1013 */ 1014 void enableVideoCalling(boolean enable); 1015 1016 /** 1017 * Whether video calling has been enabled by the user. 1018 * 1019 * @param callingPackage The package making the call. 1020 * @return {@code true} if the user has enabled video calling, {@code false} otherwise. 1021 */ 1022 boolean isVideoCallingEnabled(String callingPackage); 1023 1024 /** 1025 * Whether the DTMF tone length can be changed. 1026 * 1027 * @return {@code true} if the DTMF tone length can be changed. 1028 */ 1029 boolean canChangeDtmfToneLength(); 1030 1031 /** 1032 * Whether the device is a world phone. 1033 * 1034 * @return {@code true} if the devices is a world phone. 1035 */ 1036 boolean isWorldPhone(); 1037 1038 /** 1039 * Whether the phone supports TTY mode. 1040 * 1041 * @return {@code true} if the device supports TTY mode. 1042 */ 1043 boolean isTtyModeSupported(); 1044 1045 /** 1046 * Whether the phone supports hearing aid compatibility. 1047 * 1048 * @return {@code true} if the device supports hearing aid compatibility. 1049 */ 1050 boolean isHearingAidCompatibilitySupported(); 1051 1052 /** 1053 * Get IMS Registration Status 1054 */ 1055 boolean isImsRegistered(); 1056 1057 /** 1058 * Returns the Status of Wi-Fi Calling 1059 */ 1060 boolean isWifiCallingAvailable(); 1061 1062 /** 1063 * Returns the Status of Volte 1064 */ 1065 boolean isVolteAvailable(); 1066 1067 /** 1068 * Returns the Status of VT (video telephony) 1069 */ 1070 boolean isVideoTelephonyAvailable(); 1071 1072 /** 1073 * Returns the unique device ID of phone, for example, the IMEI for 1074 * GSM and the MEID for CDMA phones. Return null if device ID is not available. 1075 * 1076 * @param callingPackage The package making the call. 1077 * <p>Requires Permission: 1078 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1079 */ 1080 String getDeviceId(String callingPackage); 1081 1082 /** 1083 * Returns the IMEI for the given slot. 1084 * 1085 * @param slotIndex - device slot. 1086 * @param callingPackage The package making the call. 1087 * <p>Requires Permission: 1088 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1089 */ 1090 String getImeiForSlot(int slotIndex, String callingPackage); 1091 1092 /** 1093 * Returns the MEID for the given slot. 1094 * 1095 * @param slotIndex - device slot. 1096 * @param callingPackage The package making the call. 1097 * <p>Requires Permission: 1098 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1099 */ 1100 String getMeidForSlot(int slotIndex, String callingPackage); 1101 1102 /** 1103 * Returns the device software version. 1104 * 1105 * @param slotIndex - device slot. 1106 * @param callingPackage The package making the call. 1107 * <p>Requires Permission: 1108 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1109 */ 1110 String getDeviceSoftwareVersionForSlot(int slotIndex, String callingPackage); 1111 1112 /** 1113 * Returns the subscription ID associated with the specified PhoneAccount. 1114 */ 1115 int getSubIdForPhoneAccount(in PhoneAccount phoneAccount); 1116 1117 void factoryReset(int subId); 1118 1119 /** 1120 * An estimate of the users's current locale based on the default SIM. 1121 * 1122 * The returned string will be a well formed BCP-47 language tag, or {@code null} 1123 * if no locale could be derived. 1124 */ 1125 String getLocaleFromDefaultSim(); 1126 1127 /** 1128 * Requests the modem activity info asynchronously. 1129 * The implementor is expected to reply with the 1130 * {@link android.telephony.ModemActivityInfo} object placed into the Bundle with the key 1131 * {@link android.telephony.TelephonyManager#MODEM_ACTIVITY_RESULT_KEY}. 1132 * The result code is ignored. 1133 */ 1134 oneway void requestModemActivityInfo(in ResultReceiver result); 1135 1136 /** 1137 * Get the service state on specified subscription 1138 * @param subId Subscription id 1139 * @param callingPackage The package making the call 1140 * @return Service state on specified subscription. 1141 */ 1142 ServiceState getServiceStateForSubscriber(int subId, String callingPackage); 1143 1144 /** 1145 * Returns the URI for the per-account voicemail ringtone set in Phone settings. 1146 * 1147 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the 1148 * voicemail ringtone. 1149 * @return The URI for the ringtone to play when receiving a voicemail from a specific 1150 * PhoneAccount. 1151 */ 1152 Uri getVoicemailRingtoneUri(in PhoneAccountHandle accountHandle); 1153 1154 /** 1155 * Sets the per-account voicemail ringtone. 1156 * 1157 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or 1158 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}. 1159 * 1160 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the 1161 * voicemail ringtone. 1162 * @param uri The URI for the ringtone to play when receiving a voicemail from a specific 1163 * PhoneAccount. 1164 */ 1165 void setVoicemailRingtoneUri(String callingPackage, 1166 in PhoneAccountHandle phoneAccountHandle, in Uri uri); 1167 1168 /** 1169 * Returns whether vibration is set for voicemail notification in Phone settings. 1170 * 1171 * @param accountHandle The handle for the {@link PhoneAccount} for which to retrieve the 1172 * voicemail vibration setting. 1173 * @return {@code true} if the vibration is set for this PhoneAccount, {@code false} otherwise. 1174 */ 1175 boolean isVoicemailVibrationEnabled(in PhoneAccountHandle accountHandle); 1176 1177 /** 1178 * Sets the per-account preference whether vibration is enabled for voicemail notifications. 1179 * 1180 * <p>Requires that the calling app is the default dialer, or has carrier privileges, or 1181 * has permission {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}. 1182 * 1183 * @param phoneAccountHandle The handle for the {@link PhoneAccount} for which to set the 1184 * voicemail vibration setting. 1185 * @param enabled Whether to enable or disable vibration for voicemail notifications from a 1186 * specific PhoneAccount. 1187 */ 1188 void setVoicemailVibrationEnabled(String callingPackage, 1189 in PhoneAccountHandle phoneAccountHandle, boolean enabled); 1190 1191 /** 1192 * Returns a list of packages that have carrier privileges. 1193 */ 1194 List<String> getPackagesWithCarrierPrivileges(); 1195 1196 /** 1197 * Return the application ID for the app type. 1198 * 1199 * @param subId the subscription ID that this request applies to. 1200 * @param appType the uicc app type, 1201 * @return Application ID for specificied app type or null if no uicc or error. 1202 */ 1203 String getAidForAppType(int subId, int appType); 1204 1205 /** 1206 * Return the Electronic Serial Number. 1207 * 1208 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 1209 * 1210 * @param subId the subscription ID that this request applies to. 1211 * @return ESN or null if error. 1212 * @hide 1213 */ 1214 String getEsn(int subId); 1215 1216 /** 1217 * Return the Preferred Roaming List Version 1218 * 1219 * Requires that the calling app has READ_PRIVILEGED_PHONE_STATE permission 1220 * @param subId the subscription ID that this request applies to. 1221 * @return PRLVersion or null if error. 1222 * @hide 1223 */ 1224 String getCdmaPrlVersion(int subId); 1225 1226 /** 1227 * Get snapshot of Telephony histograms 1228 * @return List of Telephony histograms 1229 * Requires Permission: 1230 * {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} 1231 * Or the calling app has carrier privileges. 1232 */ 1233 List<TelephonyHistogram> getTelephonyHistograms(); 1234 1235 /** 1236 * Set the allowed carrier list for slotIndex 1237 * Require system privileges. In the future we may add this to carrier APIs. 1238 * 1239 * @return The number of carriers set successfully. Should match length of 1240 * carriers on success. 1241 */ 1242 int setAllowedCarriers(int slotIndex, in List<CarrierIdentifier> carriers); 1243 1244 /** 1245 * Get the allowed carrier list for slotIndex. 1246 * Require system privileges. In the future we may add this to carrier APIs. 1247 * 1248 * @return List of {@link android.service.carrier.CarrierIdentifier}; empty list 1249 * means all carriers are allowed. 1250 */ 1251 List<CarrierIdentifier> getAllowedCarriers(int slotIndex); 1252 1253 /** 1254 * Action set from carrier signalling broadcast receivers to enable/disable metered apns 1255 * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required 1256 * @param subId the subscription ID that this action applies to. 1257 * @param enabled control enable or disable metered apns. 1258 * @hide 1259 */ 1260 void carrierActionSetMeteredApnsEnabled(int subId, boolean visible); 1261 1262 /** 1263 * Action set from carrier signalling broadcast receivers to enable/disable radio 1264 * Permissions android.Manifest.permission.MODIFY_PHONE_STATE is required 1265 * @param subId the subscription ID that this action applies to. 1266 * @param enabled control enable or disable radio. 1267 * @hide 1268 */ 1269 void carrierActionSetRadioEnabled(int subId, boolean enabled); 1270 1271 /** 1272 * Get aggregated video call data usage since boot. 1273 * Permissions android.Manifest.permission.READ_NETWORK_USAGE_HISTORY is required. 1274 * @return total data usage in bytes 1275 * @hide 1276 */ 1277 long getVtDataUsage(); 1278 1279 /** 1280 * Policy control of data connection. Usually used when data limit is passed. 1281 * @param enabled True if enabling the data, otherwise disabling. 1282 * @param subId Subscription index 1283 * @hide 1284 */ 1285 void setPolicyDataEnabled(boolean enabled, int subId); 1286 1287 /** 1288 * Get Client request stats which will contain statistical information 1289 * on each request made by client. 1290 * @param callingPackage package making the call. 1291 * @param subId Subscription index 1292 * @hide 1293 */ 1294 List<ClientRequestStats> getClientRequestStats(String callingPackage, int subid); 1295 1296 /** 1297 * Set SIM card power state. Request is equivalent to inserting or removing the card. 1298 * @param slotIndex SIM slot id 1299 * @param powerUp True if powering up the SIM, otherwise powering down 1300 * @hide 1301 * */ 1302 void setSimPowerStateForSlot(int slotIndex, boolean powerUp); 1303 1304 /** 1305 * Returns a list of Forbidden PLMNs from the specified SIM App 1306 * Returns null if the query fails. 1307 * 1308 * 1309 * <p>Requires that the calling app has READ_PRIVILEGED_PHONE_STATE 1310 * 1311 * @param subId subscription ID used for authentication 1312 * @param appType the icc application type, like {@link #APPTYPE_USIM} 1313 */ 1314 String[] getForbiddenPlmns(int subId, int appType); 1315 1316 /** 1317 * Check if phone is in emergency callback mode 1318 * @return true if phone is in emergency callback mode 1319 * @param subId the subscription ID that this action applies to. 1320 * @hide 1321 */ 1322 boolean getEmergencyCallbackMode(int subId); 1323} 1324