1 /* 2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef OHOS_RIL_VENDOR_CALL_DEFS_H 17 #define OHOS_RIL_VENDOR_CALL_DEFS_H 18 19 #include <stddef.h> 20 21 #include "hril_enum.h" 22 #include "hril_public_struct.h" 23 24 #ifdef __cplusplus 25 extern "C" { 26 #endif 27 28 /** 29 * @brief From 3GPP TS 27.007 V4.3.0 (2001-12) AT+CGDCONT 30 */ 31 typedef struct { 32 /** 33 * Call identification number as described in 3GPP TS 22.030 [19] sub-clause 6.5.5.1. 34 * This number can be used in +CHLD command operations 35 */ 36 int32_t index; 37 38 /** 39 * 0: mobile originated (MO) call 40 * 1: mobile terminated (MT) call 41 */ 42 int32_t dir; 43 44 /** call state */ 45 HRilCallState state; 46 47 /** call mode */ 48 HRilCallMode mode; 49 50 /** 51 * 0: call is not one of multiparty (conference) call parties 52 * 1: call is one of multiparty (conference) call parties 53 */ 54 int32_t mpty; 55 56 /** 57 * Identifies the service domain. 58 * 0: CS domain phone 59 * 1: IMS domain phone 60 */ 61 int32_t voiceDomain; 62 63 /** 64 * 0: voice call 65 * 1: Video call: send one-way video, two-way voice 66 * 2: Video call: one-way receiving video, two-way voice 67 * 3: Video call: two-way video, two-way voice 68 */ 69 int32_t callType; 70 71 /** Phone number in format specified by <type> */ 72 char *number; 73 74 /** 75 * Type of address octet in integer format (refer TS 24.008 [8] subclauses 10.5.4.7); 76 * default 145 when dialling string includes international access code character "+", 77 * otherwise 129. see 3GPP TS 27.007 V4.3.0 (2001-12) 6.1 78 */ 79 int32_t type; 80 81 /** 82 * Alphanumeric representation of <number> corresponding to the entry found 83 * in phonebook; used character set should be the one selected with command 84 * select TE character set +CSCS 85 */ 86 char *alpha; 87 88 /** 89 * Indicates remote party name 90 */ 91 char *name; 92 93 /** 94 * Identifies the CNAP display name; 95 * - 0: Allowed 96 * - 1: Restricted 97 * - 2: Not Specified/Unkonwn 98 * - 3: Payphone 99 */ 100 int32_t namePresentation; 101 } HRilCallInfo; 102 103 /** 104 * @brief From 3GPP TS 27.007 V4.3.0 (2001-12) ATD%s%s 105 */ 106 typedef struct { 107 /** 108 * Type of address octet in integer format (refer TS 24.008 [8] subclauses 10.5.4.7); 109 * default 145 when dialling string includes international access code character "+", otherwise 110 * 129. 111 */ 112 char *address; 113 114 /** 115 * This command refers to CLIR service according to 3GPP TS 22.081 [3] that allows a calling 116 * subscriber to enable or disable the presentation of the CLI to the called party when originating 117 * a call. <n> (parameter sets the adjustment for outgoing calls): 0 presentation indicator is used 118 * according to the subscription of the CLIR service 1 CLIR invocation 2 CLIR suppression <m> 119 * (parameter shows the subscriber CLIR service status in the network): 0 CLIR not provisioned 1 120 * CLIR provisioned in permanent mode 2 unknown (e.g. no network, etc.) 3 CLIR temporary mode 121 * presentation restricted 4 CLIR temporary mode presentation allowed 122 */ 123 int32_t clir; 124 } HRilDial; 125 126 /** 127 * @brief Defines the call forwarding information. 128 */ 129 typedef struct { 130 /** Call forwarding type <0-5> */ 131 int32_t reason; 132 133 /** Call forwarding operation mode */ 134 int32_t mode; 135 136 /** Phone number */ 137 char *number; 138 139 /** 140 * Is a sum of integers each representing a class of information default 255 141 * 1: voice (telephony) 142 * 2: data (refers to all bearer services; with <mode>=2 this may refer 143 * only to some bearer service if TA does not support values 16, 32, 64 and 128) 144 * 4: fax (facsimile services) 145 * 8: short message service 146 * 16: data circuit sync 147 * 32: data circuit async 148 * 64: dedicated packet access 149 * 128: dedicated PAD access 150 */ 151 int32_t classx; 152 153 /** 154 * when "no reply" is enabled or queried, this gives the time in seconds to wait 155 * before call is forwarded, default value 20 156 */ 157 int32_t time; 158 159 /** 0: not active, 1: active */ 160 int32_t status; 161 } HRilCFInfo; 162 163 /** 164 * @brief Defines the dual tone multi-frequency (DTMF) information. 165 */ 166 typedef struct { 167 /** Call ID */ 168 int32_t callId; 169 170 /** DTMF keyword */ 171 const char *dtmfKey; 172 173 /** Duration for playing the DTMF tone */ 174 int32_t onLength; 175 176 /** Interval for sending DTMF signals */ 177 int32_t offLength; 178 179 /** DTMF string length */ 180 int32_t stringLength; 181 } CallDtmfInfo; 182 183 /** 184 * @brief Defines the call restriction password. 185 */ 186 typedef struct { 187 /** Operation object */ 188 const char *fac; 189 190 /** 191 * Operation mode: 192 * 0: deactivation 193 * 1: activation 194 */ 195 int32_t mode; 196 197 /** Password */ 198 const char *password; 199 } CallRestrictionInfo; 200 201 /** 202 * @brief Defines the call restriction password. 203 */ 204 typedef struct { 205 /** Operation object */ 206 const char *fac; 207 208 /** Old password */ 209 const char *oldPassword; 210 211 /** New password */ 212 const char *newPassword; 213 } HRilSetBarringInfo; 214 215 /** 216 * @brief Defines the call forwarding information. 217 */ 218 typedef struct { 219 /** Call forwarding type <0-5> */ 220 int32_t reason; 221 222 /** Call forwarding status. */ 223 int32_t status; 224 225 /** 226 * Is a sum of integers each representing a class of information default 255 227 * 1: voice (telephony) 228 * 2: data (refers to all bearer services; with <mode>=2 this may refer 229 * only to some bearer service if TA does not support values 16, 32, 64 and 128) 230 * 4: fax (facsimile services) 231 * 8: short message service 232 * 16: data circuit sync 233 * 32: data circuit async 234 * 64: dedicated packet access 235 * 128: dedicated PAD access 236 */ 237 int32_t classx; 238 239 /** Call forwarding number. */ 240 char *number; 241 /** 242 * Default 145 when dialling string includes international access code 243 * character "+", otherwise 129, other value refer TS 24.008 [8] 244 * sub-clause 10.5.4.7 245 */ 246 int32_t type; 247 248 /** Time. */ 249 int32_t time; 250 } HRilCFQueryInfo; 251 252 /** 253 * @brief Defines the CLIP information. 254 */ 255 typedef struct { 256 /** Parameter sets/shows the result code presentation status in the TA */ 257 int32_t action; 258 259 /** 260 * Parameter shows the subscriber CLIP service status in the network, <0-4> 261 */ 262 int32_t clipStat; 263 } HRilGetClipResult; 264 265 /** 266 * @brief Defines the CLIR information. 267 */ 268 typedef struct { 269 /** Parameter sets/shows the result code presentation status in the TA */ 270 int32_t action; 271 272 /** 273 * Parameter shows the subscriber CLIP service status in the network, 274 * <0-4> 275 */ 276 int32_t clirStat; 277 } HRilGetCallClirResult; 278 279 /** 280 * @brief Defines the call waiting information. 281 */ 282 typedef struct { 283 /** Call wait status, could be 0 or 1 */ 284 int32_t status; 285 286 /** 287 * 1: voice (telephony); 288 * 2: data; 289 * 4: fax (facsimile services); 290 * 8: short message service; 291 * 16: data circuit sync; 292 * 32: data circuit async; 293 * 64: dedicated packet access; 294 * 128: dedicated PAD access. 295 */ 296 int32_t classCw; 297 } HRilCallWaitResult; 298 299 /** 300 * @brief Defines the call barring information. 301 */ 302 typedef struct { 303 /** Call restructuib status, could be 0 or 1 */ 304 int32_t status; 305 306 /** 307 * 1: voice (telephony); 308 * 2: data; 309 * 4: fax (facsimile services); 310 * 8: short message service; 311 * 16: data circuit sync; 312 * 32: data circuit async; 313 * 64: dedicated packet access; 314 * 128: dedicated PAD access. 315 */ 316 int32_t classCw; 317 } HRilCallRestrictionResult; 318 319 /** 320 * @brief Defines the USSD result information. 321 */ 322 typedef struct { 323 /** 324 * Integer value. 325 * 0: The network does not require a TE reply (USSD-Notify initiated by the network or TE 326 * The network does not need further information after starting operation); 327 * 1: The network needs a TE reply (USSD-Request initiated by the network, or TE sent 328 * After starting the operation, the network needs further information); 329 * 2: The USSD session is released by the network; 330 * 3: Other local clients have responded; 331 * 4: The operation is not supported; 332 * 5: The network timed out. 333 */ 334 int32_t m; 335 336 /** 337 * USSD string, the maximum length is 160 characters. 338 */ 339 char *str; 340 } HRilUssdNoticeInfo; 341 342 /** 343 * @brief Defines the supplementary service information. 344 */ 345 typedef struct { 346 /** 347 * Service type: 348 * 0: call forwarding unconditional 349 * 1: call forwarding on busy 350 * 2: call forwarding on no reply 351 * 3: call forwarding not reachable (no network service, or power-off) 352 */ 353 int32_t serviceType; 354 355 /** 356 * Request type: 357 * 0: deactivation 358 * 1: activated 359 * 2: status query 360 * 3: registration 361 * 4: deletion 362 */ 363 int32_t requestType; 364 365 /** Service class. For details, see 3GPP TS 27.007. */ 366 int32_t serviceClass; 367 368 /** The result of the SS request */ 369 int32_t result; 370 } HRilSsNoticeInfo; 371 372 /** 373 * @brief Defines the emergency information. 374 */ 375 typedef struct { 376 /** Number index */ 377 int32_t index; 378 379 /** Total number of numbers */ 380 int32_t total; 381 382 /** Emergency call number in string format */ 383 char *eccNum; 384 385 /** 386 * Emergency call type 387 * 0: interface message of initiating an emergency call 388 * 1: Bandit police 389 * 2: Rescue 390 * 4: Fire alarm 391 * 8: Marine Police 392 * 16: Alpine rescue 393 */ 394 int32_t category; 395 396 /** 397 * The number is valid with or without a card 398 * 0: valid without card 399 * 1: Valid with card 400 */ 401 int32_t simpresent; 402 403 /** Country code */ 404 char *mcc; 405 406 /** 407 * Distinguishes CS domain abnormal service status 408 * 0: all States are valid 409 * 1: the CS domain is not in normal service 410 */ 411 int32_t abnormalService; 412 } HRilEmergencyInfo; 413 414 /** 415 * @brief Active reporting of SRVCC status is controlled by the +CIREP command. 416 * 417 * This command complies with the 3GPP TS 27.007 protocol. 418 */ 419 typedef struct { 420 /** 421 * SRVCC status. 422 * 1: SRVCC starts; 423 * 2: SRVCC is successful; 424 * 3: SRVCC is cancelled; 425 * 4: SRVCC failed. 426 */ 427 int32_t status; 428 } HRilCallSrvccStatus; 429 430 /** 431 * @brief Query the bandwidth information of the voice channel during the call. 432 * 433 * Note: Modem private commands, not a reported field specified by the 3gpp 434 * protocol. 435 */ 436 typedef struct { 437 /** 438 * Integer value, voice channel type: 439 * 0: No in-band audio information; 440 * 1: In-band voice is available, narrowband voice; 441 * 2: In-band voice is available, broadband voice. 442 */ 443 int32_t status; 444 445 /** 446 * Integer value, call domain of voice call: 447 * 0: 3GPP CS domain voice call; 448 * 1: IMS domain voice call; 449 * 2: 3GPP2 CS domain voice call. 450 */ 451 int32_t voiceDomain; 452 } HRilCallCsChannelInfo; 453 454 /** 455 * @brief Defines the supplementary service notifications information. 456 */ 457 typedef struct { 458 /** Type of notification: 0 = code1(MO); 1 = code2(MT) */ 459 int32_t notificationType; 460 461 /** TS 27.007 7.17 "code1" or "code2" */ 462 int32_t code; 463 464 /** TS 27.007 7.17 "index" */ 465 int32_t index; 466 467 /** TS 27.007 7.17 "type" (MT only) */ 468 int32_t type; 469 470 /** TS 27.007 7.17 "number" (MT only) */ 471 char *number; 472 } HRilSuppSvcNotification; 473 474 typedef struct { 475 /** 476 * @brief Gets the call status list. 477 * 478 * @param requestInfo Request data info, for details, see {@link 479 * ReqDataInfo} 480 * @see ReqDataInfo 481 */ 482 void (*GetCallList)(const ReqDataInfo *requestInfo); 483 484 /** 485 * @brief Makes a call. 486 * 487 * @param requestInfo Request data info, for details, see {@link 488 * ReqDataInfo} 489 * @param data HRilDial, for details, see {@link HRilDial} 490 * @param dataLen The length of data. 491 * @see ReqDataInfo | HRilDial 492 */ 493 void (*Dial)(const ReqDataInfo *requestInfo, const HRilDial *data, size_t dataLen); 494 495 /** 496 * @brief Ends a call. 497 * 498 * @param requestInfo Request data info, for details, see {@link 499 * ReqDataInfo} 500 * @param data gsmIndex, Indicates the connection index 501 * @param dataLen The length of data. 502 * @see ReqDataInfo 503 */ 504 void (*Hangup)(const ReqDataInfo *requestInfo, const uint32_t *data, size_t dataLen); 505 506 /** 507 * @brief Rejects a call. 508 * 509 * @param requestInfo Request data info, for details, see {@link 510 * ReqDataInfo}. 511 * @see ReqDataInfo 512 */ 513 void (*Reject)(const ReqDataInfo *requestInfo); 514 515 /** 516 * @brief Answers a call. 517 * 518 * @param requestInfo Request data info, for details, see {@link 519 * ReqDataInfo} 520 * @see ReqDataInfo 521 */ 522 void (*Answer)(const ReqDataInfo *requestInfo); 523 524 /** 525 * @brief Obtains the calling line identification presentation (CLIP) 526 * information. 527 * 528 * @param requestInfo Request data info, for details, see {@link 529 * ReqDataInfo} 530 * @see ReqDataInfo 531 */ 532 void (*GetClip)(const ReqDataInfo *requestInfo); 533 534 /** 535 * @brief Sets the calling line identification presentation (CLIP) 536 * information. 537 * 538 * @param requestInfo Request data info, for details, see {@link 539 * ReqDataInfo}. 540 * @param action Whether to enable or disable the CLIP function. The value 541 * 0 means to disable the CLIP function, and the value 1 means the 542 * opposite. 543 * @see ReqDataInfo 544 */ 545 void (*SetClip)(const ReqDataInfo *requestInfo, int32_t action); 546 547 /** 548 * @brief Holds a call. 549 * 550 * @param requestInfo Request data info, for details, see {@link 551 * ReqDataInfo}. 552 * @see ReqDataInfo 553 */ 554 void (*HoldCall)(const ReqDataInfo *requestInfo); 555 556 /** 557 * @brief Unholds a call. 558 * 559 * @param requestInfo Request data info, for details, see {@link 560 * ReqDataInfo}. 561 * @see ReqDataInfo 562 */ 563 void (*UnHoldCall)(const ReqDataInfo *requestInfo); 564 565 /** 566 * @brief Switches a call. 567 * 568 * @param requestInfo Request data info, for details, see {@link 569 * ReqDataInfo}. 570 * @see ReqDataInfo 571 */ 572 void (*SwitchCall)(const ReqDataInfo *requestInfo); 573 574 /** 575 * @brief Combines calls into a conference call. 576 * 577 * @param requestInfo Request data info, for details, see {@link 578 * ReqDataInfo}. 579 * @param callType Call type. 580 * @see ReqDataInfo 581 */ 582 void (*CombineConference)(const ReqDataInfo *requestInfo, int32_t callType); 583 584 /** 585 * @brief Separates calls from a conference call. 586 * 587 * @param requestInfo Request data info, for details, see {@link 588 * ReqDataInfo}. 589 * @param callType Call type. 590 * @see ReqDataInfo 591 */ 592 void (*SeparateConference)(const ReqDataInfo *requestInfo, int32_t callIndex, int32_t callType); 593 594 /** 595 * @brief Holds and resumes a call. 596 * 597 * @param requestInfo Request data info, for details, see {@link 598 * ReqDataInfo}. 599 * @param type Type of ending calls. The value 0 indicates that the call is 600 * ended directly; The value 1 means release the held call and the wait 601 * call; The value 2 means that release the active call and recover the 602 * held call; The value 3 means that release all calls. 603 * @see ReqDataInfo 604 */ 605 void (*CallSupplement)(const ReqDataInfo *requestInfo, int32_t type); 606 607 /** 608 * @brief Gets the call waiting status. 609 * 610 * @param requestInfo Request data info, for details, see {@link 611 * ReqDataInfo}. 612 * @see ReqDataInfo 613 */ 614 void (*GetCallWaiting)(const ReqDataInfo *requestInfo); 615 616 /** 617 * @brief Sets the call waiting status. 618 * 619 * @param requestInfo Request data info, for details, see {@link 620 * ReqDataInfo}. 621 * @param active Whether to enable or disable call waiting. The value 622 * <b>0</b> means to disable the call waiting function, and the value 623 * <b>1</b> means the opposite. 624 * @see ReqDataInfo 625 */ 626 void (*SetCallWaiting)(const ReqDataInfo *requestInfo, int32_t active); 627 628 /** 629 * @brief Sets the call forwarding status. 630 * 631 * @param requestInfo Request data info, for details, see {@link 632 * ReqDataInfo}. 633 * @param info Call forwarding information, for details, see {@link 634 * CallForwardSetInfo}. 635 * @see ReqDataInfo 636 */ 637 void (*SetCallTransferInfo)(const ReqDataInfo *requestInfo, HRilCFInfo info); 638 639 /** 640 * @brief Gets the call forwarding information. 641 * 642 * @param requestInfo Request data info, for details, see {@link 643 * ReqDataInfo}. 644 * @param reason Call forwarding type, The value 0 indicates unconditional 645 * call forwarding, 1 indicates call forwarding when the user is busy, 2 646 * indicates call forwarding when the user does not reply, and 3 indicates 647 * call forwarding when the user is unreachable. 648 * @see ReqDataInfo 649 */ 650 void (*GetCallTransferInfo)(const ReqDataInfo *requestInfo, int32_t reason); 651 652 /** 653 * @brief Gets the call restriction information. 654 * 655 * @param requestInfo Request data info, for details, see {@link 656 * ReqDataInfo}. 657 * @param fac Object for call restriction. 658 * @see ReqDataInfo 659 */ 660 void (*GetCallRestriction)(const ReqDataInfo *requestInfo, const char *fac); 661 662 /** 663 * @brief Sets the call restriction information. 664 * 665 * @param requestInfo Request data info, for details, see {@link 666 * ReqDataInfo}. 667 * @param info Call restriction information. 668 * @see ReqDataInfo 669 */ 670 void (*SetCallRestriction)(const ReqDataInfo *requestInfo, CallRestrictionInfo info); 671 672 /** 673 * @brief Obtains the calling line identification restriction (CLIR) 674 * information. 675 * 676 * @param requestInfo Request data info, for details, see {@link 677 * ReqDataInfo}. 678 * @see ReqDataInfo 679 */ 680 void (*GetClir)(const ReqDataInfo *requestInfo); 681 682 /** 683 * @brief Sets the CLIR information. 684 * 685 * @param requestInfo Request data info, for details, see {@link 686 * ReqDataInfo}. 687 * @param action Whether to enable or disable the CLIR function. The value 688 * 0 means to disable the CLIR function, and the value 1 means the 689 * opposite. 690 * @see ReqDataInfo 691 */ 692 void (*SetClir)(const ReqDataInfo *requestInfo, int32_t action); 693 694 /** 695 * @brief Enables DTMF. 696 * 697 * @param requestInfo Request data info, for details, see {@link 698 * ReqDataInfo}. 699 * @param info DTMF information. 700 * @see ReqDataInfo | CallDtmfInfo 701 */ 702 void (*StartDtmf)(const ReqDataInfo *requestInfo, CallDtmfInfo info); 703 704 /** 705 * @brief Sends dual tone multi-frequency (DTMF). 706 * 707 * @param requestInfo Request data info, for details, see {@link 708 * ReqDataInfo}. 709 * @param info DTMF information. 710 * @see ReqDataInfo | CallDtmfInfo 711 */ 712 void (*SendDtmf)(const ReqDataInfo *requestInfo, CallDtmfInfo info); 713 714 /** 715 * @brief Disables DTMF. 716 * 717 * @param requestInfo Request data info, for details, see {@link 718 * ReqDataInfo}. 719 * @param info DTMF information. 720 * @see ReqDataInfo | CallDtmfInfo 721 */ 722 void (*StopDtmf)(const ReqDataInfo *requestInfo, CallDtmfInfo info); 723 724 /** 725 * @brief Gets IMS call list. 726 * 727 * @param requestInfo Request data info, for details, see {@link 728 * ReqDataInfo}. 729 * @see ReqDataInfo 730 */ 731 void (*GetImsCallList)(const ReqDataInfo *requestInfo); 732 733 /** 734 * @brief Obtains the call preference mode. 735 * 736 * @param requestInfo Request data info, for details, see {@link 737 * ReqDataInfo}. 738 * @see ReqDataInfo 739 */ 740 void (*GetCallPreferenceMode)(const ReqDataInfo *requestInfo); 741 742 /** 743 * @brief Sets the call preference mode. 744 * 745 * @param requestInfo Request data info, for details, see {@link 746 * ReqDataInfo}. 747 * @see ReqDataInfo 748 */ 749 void (*SetCallPreferenceMode)(const ReqDataInfo *requestInfo, int32_t mode); 750 751 /** 752 * @brief Gets LTE IMS switch status. 753 * 754 * @param requestInfo Request data info, for details, see {@link 755 * ReqDataInfo}. 756 * @see ReqDataInfo 757 */ 758 void (*GetLteImsSwitchStatus)(const ReqDataInfo *requestInfo); 759 760 /** 761 * @brief Sets LTE IMS switch status. 762 * 763 * @param requestInfo Request data info, for details, see {@link 764 * ReqDataInfo}. 765 * @param active Whether to enable or disable call waiting. The value 766 * <b>0</b> means to disable the call waiting function, and the value 767 * <b>1</b> means the opposite. 768 * @see ReqDataInfo 769 */ 770 void (*SetLteImsSwitchStatus)(const ReqDataInfo *requestInfo, int32_t active); 771 772 /** 773 * @brief Sets unstructured supplementary service data (USSD) information. 774 * 775 * @param requestInfo Request data info, for details, see {@link 776 * ReqDataInfo}. 777 * @param str USSD information. 778 * @see ReqDataInfo 779 */ 780 void (*SetUssd)(const ReqDataInfo *requestInfo, const char *str); 781 782 /** 783 * @brief Obtains the USSD information. 784 * 785 * @param requestInfo Request data info, for details, see {@link 786 * ReqDataInfo}. 787 * @see ReqDataInfo 788 */ 789 void (*GetUssd)(const ReqDataInfo *requestInfo); 790 791 /** 792 * @brief Sets the mute mode. 793 * 794 * @param requestInfo Request data info, for details, see {@link 795 * ReqDataInfo}. 796 * @param mute Whether to enable the mute function. The value 0 means to 797 * disable the mute function, and the value 1 means the opposite. 798 * @see ReqDataInfo 799 */ 800 void (*SetMute)(const ReqDataInfo *requestInfo, int32_t mute); 801 802 /** 803 * @brief Obtains the mute mode. 804 * 805 * @param requestInfo Request data info, for details, see {@link 806 * ReqDataInfo}. 807 * @see ReqDataInfo 808 */ 809 void (*GetMute)(const ReqDataInfo *requestInfo); 810 811 /** 812 * @brief Obtains the emergency number. 813 * 814 * @param requestInfo Request data info, for details, see {@link 815 * ReqDataInfo}. 816 * @see ReqDataInfo 817 */ 818 void (*GetEmergencyCallList)(const ReqDataInfo *requestInfo); 819 820 /** 821 * @brief Obtains the call failure cause. 822 * 823 * @param requestInfo Request data info, for details, see {@link 824 * ReqDataInfo}. 825 * @see ReqDataInfo 826 */ 827 void (*GetCallFailReason)(const ReqDataInfo *requestInfo); 828 829 /** 830 * @brief Sets the emergency call number. 831 * 832 * @param requestInfo Request data info, for details, see {@link 833 * ReqDataInfo}. 834 * @param emergencyInfo Emergency call information. 835 * @param len The size of emergencyInfo. 836 * @see ReqDataInfo 837 */ 838 void (*SetEmergencyCallList)(const ReqDataInfo *requestInfo, HRilEmergencyInfo *emergencyInfo, const int len); 839 840 /** 841 * @brief Change call barring facility password. 842 * 843 * @param requestInfo Request data info, for details, see {@link 844 * ReqDataInfo}. 845 * @param info Call restriction information. 846 * @see ReqDataInfo 847 */ 848 void (*SetBarringPassword)(const ReqDataInfo *requestInfo, HRilSetBarringInfo info); 849 850 /** 851 * @brief Close unfinished unstructured supplementary service data (USSD). 852 * 853 * @param requestInfo Request data info, for details, see {@link 854 * ReqDataInfo}. 855 * @see ReqDataInfo 856 */ 857 void (*CloseUnFinishedUssd)(const ReqDataInfo *requestInfo); 858 void (*ExplicitCallTransferConnection)(const ReqDataInfo *requestInfo); 859 void (*SetVonrSwitch)(const ReqDataInfo *requestInfo, int32_t status); 860 861 /** 862 * @brief Enable or disable supplementary service related notification from the network. 863 * 864 * @param requestInfo Request data info, for details, see {@link 865 * ReqDataInfo}. 866 * @param enable Whether to enable notification, 0 indicates disable, 1 indicates enable. 867 * @see ReqDataInfo 868 */ 869 void (*SetSuppSrvNotification)(const ReqDataInfo *requestInfo, int32_t enable); 870 871 /** 872 * @brief Get the TTY mode. 873 * 874 * @param requestInfo Request data info, for details, see {@link 875 * ReqDataInfo}. 876 * @see ReqDataInfo 877 */ 878 void (*GetTTYMode)(const ReqDataInfo *requestInfo); 879 880 /** 881 * @brief Set the TTY mode. 882 * 883 * @param requestInfo Request data info, for details, see {@link 884 * ReqDataInfo}. 885 * @param mode The TTY mode to set, value as following: 886 * - 0 indicates TTYMode#TTY_MODE_OFF 887 * - 1 indicates TTYMode#TTY_MODE_FULL 888 * - 2 indicates TTYMode#TTY_MODE_HCO 889 * - 3 indicates TTYMode#TTY_MODE_VCO 890 * @see ReqDataInfo 891 */ 892 void (*SetTTYMode)(const ReqDataInfo *requestInfo, int32_t mode); 893 } HRilCallReq; 894 #ifdef __cplusplus 895 } 896 #endif 897 #endif // OHOS_RIL_VENDOR_CALL_DEFS_H 898