include/tapi/ITapiCall.h

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 /**
  22  * @open
  23  * @ingroup             TelephonyAPI
  24  * @addtogroup  TAPI_CALL       CALL
  25  * @{
  26  *
  27  * @file ITapiCall.h
  28  *
  29  * Call APIs allow an application to accomplish the following services: @n
  30  * - Make a mobile originated Emergency call, Voice call, or Video call. @n
  31  * - Accept or Reject incoming calls. @n
  32  * - Release Calls. @n
  33  * - Call dependent supplementary services such as call hold, retrieve, DTMF. @n
  34  * - Multi -party call management, setup conference call, split conference call. @n
  35  * - Call information such as get call information, get line identification number. @n
  36  * - To verify whether a call (voice / video ) is possible at any given time. @n
  37  */
  38
  39 #ifndef _ITAPI_CALL_H_
  40 #define _ITAPI_CALL_H_
  41
  42 #include <TelCall.h>
  43 #include <TelUtility.h>
  44 #include <TelDefines.h>
  45
  46 #ifdef __cplusplus
  47 extern "C"
  48 {
  49 #endif
  50
  51  /**
  52  * @brief  This function originates MO call setup. This is an asynchronous function. The function completes immediately and
  53  * call setup proceeds in background.
  54  *
  55  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
  56  * However it just means that the API request has been transfered to the CP successfully.
  57  * The actual operation result is being delivered in the corresponding event asynchronously.
  58  *
  59  * @par Sync (or) Async:
  60  * This is an Asynchronous API.
  61  *
  62  * @par Important Notes:
  63  * -  If call to tel_exe_call_mo() is successful, call handle and request ID are assigned by Telephony Server
  64  *     and returned to client by given Call Handle and Request Id parameters. MO call setup continues in
  65  *     background. There are multiple states involved in the call setup procedure. Upon request completion
  66  *     successful or not, various event notifications are sent to client along with data associated with event
  67  *     (Successful data or error information) based on the indication or response received at the Telephony Server.
  68  * -  Setting up Emergency call
  69  *     - when #TelCallType_t  is voice_call, voice call is setup unless dial_number parameter is an
  70  *     emergency number known to telephony FW (like 112 for all 2G and above, other numbers may operator
  71  *     specific or device configuration specific, so Telephony FW will read relevant SIM files and refer to internal
  72  *     configuration records). If an emergency number is passed and #TelCallType_t  is voice_call, Telephony
  73  *     FW shall setup emergency phone call.
  74  *     - When #TelCallType_t  is emergency call, emergency call is always set up.
  75  *
  76  * @warning
  77  * Do not use this function. This function is dedicated to the embedded call application only.
  78  * Please use its AUL interface
  79  *
  80  * @param[in] pParams
  81  * - #TelCallSetupParams_t contains the CallType(whether it is a voice call or data call etc) and number.
  82  *
  83  * @param[out] pCallHandle
  84  * - Unique handle for referring the call
  85  *
  86  * @param [out] pRequestId
  87  *   - Unique identifier for a particular request.
  88  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
  89  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
  90  *
  91  * @par Async Response Message:
  92  * TAPI_EVENT_CALL_SETUP_CNF is sent to the application when the lower layers get the call originate response.
  93  * Asynchronous return status is indicated by #TelCallCause_t and call handle is sent in the event data.
  94  * Various asynchronous indications are described in the unsolicited notifications section . [Refer, \ref page8]
  95  *
  96  * @pre
  97  *  - Initialize Dbus connection with #tel_init
  98  *  - Register caller's application name with #tel_register_app_name
  99  *  - Register telephony events to listen
 100  *  - A event loop is running to listen events
 101  *
 102  * @post
 103  *  - None.
 104  *
 105  * @return Return Type (int) \n
 106  * - 0 - indicating that the operation has completed successfully. \n
 107  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 108  *
 109  * @par Prospective Clients:
 110  * Embedded call application
 111  *
 112  * @see tel_exe_call_mo tel_answer_call tel_release_call
 113  * \image html CallSetup.jpg
 114  * \image latex CallSetup.jpg
 115  *
 116  * @code
 117  * #include <ITapiCall.h>
 118  *
 119  * int ret_status =0;
 120  * unsigned int  pCallHandle;
 121  * int pRequestID=0;
 122  * TelCallSetupParams_t pParams;
 123  *
 124  * char normal[16] = "1234";//Called party number
 125  * memset(&pParams, 0, sizeof(TelCallSetupParams_t));
 126  * pParams.CallType = TAPI_CALL_TYPE_VOICE;
 127  * strcpy(pParams.szNumber,normal);
 128  *
 129  * ret_status = tel_exe_call_mo (&pParams,&pCallHandle,&pRequestID); // outgoing call
 130  * @endcode
 131  *
 132  * @remarks
 133  * - None
 134  *
 135  *
 136  */
 137 int tel_exe_call_mo(const TelCallSetupParams_t *pParams,  unsigned int  *pCallHandle,  int * pRequestId);
 138
 139  /**
 140  * @brief This function is used to answer the incoming call by accepting or rejecting the call.
 141  *
 142  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 143  * However it just means that the API request has been transfered to the CP successfully.
 144  * The actual operation result is being delivered in the corresponding event asynchronously.
 145  *
 146  * @par Sync (or) Async:
 147  * This is an Asynchronous API.
 148  *
 149  * @par Important Notes:
 150  *  - None.
 151  *
 152  * @warning
 153  * Do not use this function. This function is dedicated to the embedded call application only.
 154  * Please use its AUL interface
 155  *
 156  * @param[in] CallHandle
 157  * - This is the unique handle for referring the call. This call handle is available to Application through incoming call
 158  *   (TAPI_EVENT_CALL_INCOM_IND) event.
 159  *
 160  * @param[in] AnsType
 161  * - Answer type - accept / reject / replace / hold and accept. but, for CDMA, only accept is allowed.
 162  *
 163  * @param [out] pRequestId
 164  *   - Unique identifier for a particular request.
 165  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 166  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 167  *
 168  * @par Async Response Message:
 169  * - The event associated with this request is TAPI_EVENT_CALL_ANSWER_CNF. Asynchronous return status is
 170  *    indicated by #TelCallCause_t and call handle is sent in the event data.
 171  * - TAPI_EVENT_CALL_CONNECTED_IND / TAPI_EVENT_CALL_END_IND event will be notified in case of call is accepted/rejected.
 172  *
 173  * @pre
 174  *  - Initialize Dbus connection with #tel_init
 175  *  - Register caller's application name with #tel_register_app_name
 176  *  - Register telephony events to listen
 177  *  - A event loop is running to listen events
 178  *  - Call associated with call handle should be TAPI_CALL_STATE_INCOM state otherwise the API fails and there can be a
 179  *     maximum of 1 existing call.
 180  *
 181  * @post
 182  *  - None.
 183  *
 184  * @return Return Type (int) \n
 185  * - 0 - indicating that the operation has completed successfully. \n
 186  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 187  *
 188  * @par Prospective Clients:
 189  * Embedded call application
 190  *
 191  * @see tel_exe_call_mo tel_release_call
 192  *
 193  * \image html CallIncoming.jpg
 194  * \image latex CallIncoming.jpg
 195  *
 196  * @code
 197  * #include <ITapiCall.h>
 198  *
 199  * int  ret_status ;
 200  * unsigned int  pCallHandle;
 201  * int pRequestID=0;
 202  *
 203  * ret_status = tel_answer_call (pCallHandle,&pRequestID); // call answer
 204  * @endcode
 205  *
 206  * @remarks
 207  * - None
 208  *
 209  *
 210  * @remarks
 211  * - None
 212  *
 213  *
 214  */
 215 int tel_answer_call(unsigned int CallHandle, TelCallAnswerType_t AnsType, int * pRequestId);
 216
 217  /**
 218  *
 219  * @brief This function releases the call identified by Call Handle irrespective of call is hold or active state.
 220  * It is used when releasing specific active call in multiparty call.
 221  *
 222  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 223  * However it just means that the API request has been transfered to the CP successfully.
 224  * The actual operation result is being delivered in the corresponding event asynchronously.
 225  *
 226  *
 227  * @par Sync (or) Async:
 228  * This is an Asynchronous API.
 229  *
 230  * @par Important Notes:
 231  *  - In case of MPTY Call handle, Call end event is returned for each call in MPTY.
 232  *
 233  * @warning
 234  * Do not use this function. This function is dedicated to the embedded call application only.
 235  * Please use its AUL interface
 236  *
 237  * @param[in] CallHandle
 238  * - Unique handle for referring the call.
 239  *
 240  * @param [out] pRequestId
 241  *   - Unique identifier for a particular request.
 242  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 243  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 244  *
 245  * @par Async Response Message:
 246  * - The event associated with this request is TAPI_EVENT_CALL_RELEASE_CNF and Asynchronous return status
 247  *    is indicated by #TelCallCause_t and call handle for the released call is sent in the event data..
 248  *
 249  * - The event TAPI_EVENT_CALL_END_IND_IND is received as final asynchronous response and the associated data is #TelCallEndInfo_t.
 250  *    Asynchronous return status is indicated by #TelCallCause_t.
 251  *
 252  * @pre
 253  *  - Initialize Dbus connection with #tel_init
 254  *  - Register caller's application name with #tel_register_app_name
 255  *  - Register telephony events to listen
 256  *  - A event loop is running to listen events
 257  *  - Call handle should be valid and there should be an existing call in Active/hold state.
 258  *
 259  * @post
 260  *  - None.
 261  *
 262  * @return Return Type (int) \n
 263  * - 0 - indicating that the operation has completed successfully. \n
 264  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 265  *
 266  * @par Prospective Clients:
 267  * Embedded call application
 268  *
 269  * @see tel_exe_call_mo tel_answer_call tel_release_call_all tel_release_call_all_active
 270  *
 271  * @code
 272  * #include <ITapiCall.h>
 273  *
 274  * int ret_status ;
 275  * unsigned int  pCallHandle;
 276  * int pRequestID=0;
 277  *
 278  * ret_status = tel_release_call(pCallHandle,&pRequestID); // call release
 279  * @endcode
 280  *
 281  *
 282  * @remarks
 283  * - None
 284  *
 285  *
 286  */
 287 int tel_release_call(unsigned int  CallHandle, int * pRequestId);
 288
 289  /**
 290  *
 291  * @brief This function releases the all the calls irrespective of the call is hold or active state. Due to this API request,
 292  *        lower layers will release the call and END Indication Event will be sent to all the Applications.
 293  *
 294  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 295  * However it just means that the API request has been transfered to the CP successfully.
 296  * The actual operation result is being delivered in the corresponding event asynchronously.
 297  *
 298  * @par Sync (or) Async:
 299  * This is an Asynchronous API.
 300  *
 301  * @par Important Notes:
 302  *   - None.
 303  *
 304  * @warning
 305  * Do not use this function. This function is dedicated to the embedded call application only.
 306  * Please use its AUL interface instead of this.
 307  *
 308  *
 309  * @param [out] pRequestId
 310  *   - Unique identifier for a particular request.
 311  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 312  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 313  *
 314  * @par Async Response Message:
 315  * - This asynchronous event is received for each call getting released.The event associated with this request is
 316  *    TAPI_EVENT_CALL_END_IND_IND and the associated data is #TelCallEndInfo_t. There will be no request id present associated
 317  *    with this TAPI_EVENT_CALL_END_IND_IND when this API is called.
 318  *    Once all the calls are released, Telephony server will indicate application through TAPI Library by sending
 319  *    TAPI_EVENT_CALL_RELEASE_ALL_CNF. Asynchronous return status is indicated by #TelCallCause_t and there is no
 320  *    associated event data.
 321  *
 322  * @pre
 323  *  - Initialize Dbus connection with #tel_init
 324  *  - Register caller's application name with #tel_register_app_name
 325  *  - Register telephony events to listen
 326  *  - A event loop is running to listen events
 327  *  - None.
 328  *
 329  * @post
 330  *  - None.
 331  *
 332  * @return Return Type (int) \n
 333  * - 0 - indicating that the operation has completed successfully. \n
 334  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 335  *
 336  * @par Prospective Clients:
 337  * Embedded call application
 338  *
 339  * @code
 340  * #include <ITapiCall.h>
 341  *
 342  * int ret_status;
 343  * int pRequestID;
 344  *
 345  * ret_status = tel_release_call_all(&pRequestID); // release call all
 346  * @endcode
 347  *
 348  * @see None.
 349  *
 350  * @remarks
 351  * - None
 352  *
 353  *
 354  */
 355 /*================================================================================================*/
 356 int tel_release_call_all (int * pRequestId);
 357
 358  /**
 359  *
 360  * @brief This function releases the all activate call. Due to this API request,
 361  *          lower layers will release the call and END Indication Event will be sent to all the Applications.
 362  *
 363  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 364  * However it just means that the API request has been transfered to the CP successfully.
 365  * The actual operation result is being delivered in the corresponding event asynchronously.
 366  *
 367  * @par Sync (or) Async:
 368  * This is an Asynchronous API.
 369  *
 370  * @par Important Notes:
 371  *   - None.
 372  *
 373  * @warning
 374  * Do not use this function. This function is dedicated to the embedded call application only.
 375  * Please use its AUL interface instead of this.
 376  *  - None.
 377  *
 378  * @param [out] pRequestId
 379  *   - Unique identifier for a particular request.
 380  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 381  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 382  *
 383  * @par Async Response Message:
 384  * -
 385  *
 386  * @pre
 387  *  - Initialize Dbus connection with #tel_init
 388  *  - Register caller's application name with #tel_register_app_name
 389  *  - Register telephony events to listen
 390  *  - A event loop is running to listen events
 391  *  - None.
 392  *
 393  * @post
 394  *  - None.
 395  *
 396  * @return Return Type (int) \n
 397  * - 0 - indicating that the operation has completed successfully. \n
 398  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 399  *
 400  * @par Prospective Clients:
 401  * Embedded call application
 402  *
 403  * @code
 404  * #include <ITapiCall.h>
 405  *
 406  * int ret_status;
 407  * int pRequestID;
 408  *
 409  * ret_status = tel_release_call_all_active(&pRequestID); // release all active call
 410  * @endcode
 411  *
 412  * @see None.
 413  *
 414  * @remarks
 415  * - None
 416  *
 417  *
 418  */
 419 int tel_release_call_all_active(int *pRequestId);
 420
 421  /**
 422  *
 423  * @brief This function releases the all held call. Due to this API request,
 424  *          lower layers will release the call and END Indication Event will be sent to all the Applications.
 425  *
 426  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 427  * However it just means that the API request has been transfered to the CP successfully.
 428  * The actual operation result is being delivered in the corresponding event asynchronously.
 429  *
 430  * @par Sync (or) Async:
 431  * This is an Asynchronous API.
 432  *
 433  * @par Important Notes:
 434  *   - None.
 435  *
 436  * @warning
 437  * Do not use this function. This function is dedicated to the embedded call application only.
 438  * Please use its AUL interface instead of this.
 439  *  - None.
 440  *
 441  * @param [out] pRequestId
 442  *   - Unique identifier for a particular request.
 443  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 444  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 445  *
 446  * @par Async Response Message:
 447  * -
 448  *
 449  * @pre
 450  *  - Initialize Dbus connection with #tel_init
 451  *  - Register caller's application name with #tel_register_app_name
 452  *  - Register telephony events to listen
 453  *  - A event loop is running to listen events
 454  *  - None.
 455  *
 456  * @post
 457  *  - None.
 458  *
 459  * @return Return Type (int) \n
 460  * - 0 - indicating that the operation has completed successfully. \n
 461  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 462  *
 463  * @par Prospective Clients:
 464  * Embedded call application
 465  *
 466  * @code
 467  * #include <ITapiCall.h>
 468  *
 469  * int ret_status;
 470  * int pRequestID;
 471  *
 472  * ret_status = tel_release_call_all_held(&pRequestID); // release all held call
 473  * @endcode
 474  *
 475  * @see None.
 476  *
 477  * @remarks
 478  * - None
 479  *
 480  *
 481  */
 482
 483  int tel_release_call_all_held(int * pRequestId);
 484
 485  /**
 486  *
 487  * @brief This function puts the given call on hold. The call identified by Call Handle should be in active state.
 488  *
 489  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 490  * However it just means that the API request has been transfered to the CP successfully.
 491  * The actual operation result is being delivered in the corresponding event asynchronously.
 492  *
 493  *
 494  * @par Sync (or) Async:
 495  * This is an Asynchronous API.
 496  *
 497  * @par Important Notes:
 498  *  - Call duration for the call will be calculated from the time call has been connected until call is released,
 499  *    i.e. Time duration during the call on hold will also be counted.
 500  *
 501  * @warning
 502  * Do not use this function. This function is dedicated to the embedded call application only.
 503  * Please use its AUL interface instead of this.
 504  *
 505  *
 506  * @param[in] CallHandle
 507  *  - Unique handle for referring the call.
 508  *
 509  * @param [out] pRequestId
 510  *   - Unique identifier for a particular request.
 511  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 512  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 513  *
 514  * @par Async Response Message:
 515  * - The event associated with this request is TAPI_EVENT_CALL_HOLD_CNF. Asynchronous return status is
 516  *    indicated by #TelCallCause_t and call handle is sent in the event data.
 517  *
 518  * @pre
 519  *  - Initialize Dbus connection with #tel_init
 520  *  - Register caller's application name with #tel_register_app_name
 521  *  - Register telephony events to listen
 522  *  - A event loop is running to listen events
 523  *  - The call identified by the Call Handle should be in active state.
 524  *
 525  * @post
 526  *  - None.
 527  *
 528  * @return Return Type (int) \n
 529  * - 0 - indicating that the operation has completed successfully. \n
 530  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 531  *
 532  * @par Prospective Clients:
 533  * Embedded call application
 534  *
 535  * @code
 536  * #include <ITapiCall.h>
 537  *
 538  * int ret_status ;
 539  * unsigned int  pCallHandle;//HANDLE OF AN ACTIVE CALL
 540  * int pRequestID=0;
 541  *
 542  * ret_status = tel_hold_call(pCallHandle,&pRequestID); // hold call
 543  * @endcode
 544  *
 545  *
 546  * @see tel_retrieve_call
 547  *
 548  * @remarks
 549  * - None
 550  *
 551  *
 552  */
 553  int tel_hold_call(unsigned int CallHandle, int * pRequestId);
 554
 555  /**
 556  *
 557  * @brief This function retrieves the held call. The call identified by Call Handle must be in held state.
 558  *
 559  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 560  * However it just means that the API request has been transfered to the CP successfully.
 561  * The actual operation result is being delivered in the corresponding event asynchronously.
 562  *
 563  *
 564  * @par Sync (or) Async:
 565  * This is an Asynchronous API.
 566  *
 567  * @par Important Notes:
 568  *  - Call duration for the call will be calculated from the moment call has been connected until call is released.
 569  *
 570  * @warning
 571  * Do not use this function. This function is dedicated to the embedded call application only.
 572  * Please use its AUL interface instead of this.
 573  * - None.
 574  *
 575  *
 576  * @param[in] CallHandle
 577  *  - Unique handle for referring the call.
 578  *
 579  * @param [out] pRequestId
 580  *   - Unique identifier for a particular request.
 581  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 582  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 583  *
 584  * @par Async Response Message:
 585  * - The event associated with this request is TAPI_EVENT_CALL_RETRIEVE_CNF. Asynchronous return status is indicated
 586  *    by #TelCallCause_t and call handle is sent in the event data.
 587  *
 588  * @pre
 589  *  - Initialize Dbus connection with #tel_init
 590  *  - Register caller's application name with #tel_register_app_name
 591  *  - Register telephony events to listen
 592  *  - A event loop is running to listen events
 593  *  - Call should be in held state in order to retrieve into active state and no active call present.
 594  *
 595  * @post
 596  *  - None.
 597  *
 598  * @return Return Type (int) \n
 599  * - 0 - indicating that the operation has completed successfully. \n
 600  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 601  *
 602  * @par Prospective Clients:
 603  * Embedded call application
 604  *
 605  * @see tel_retrieve_call
 606  *
 607  * @code
 608  * #include <ITapiCall.h>
 609  *
 610  * int ret_status ;
 611  * unsigned int  pCallHandle;//held call handle
 612  * int pRequestID=0;
 613  *
 614  * ret_status = tel_retrieve_call(pCallHandle,&pRequestID); // retrieve call
 615  * @endcode
 616  *
 617  * @remarks
 618  * - None
 619  *
 620  *
 621  */
 622 int tel_retrieve_call(unsigned int CallHandle, int * pRequestId);
 623
 624  /**
 625  *
 626  * @brief Swap calls. This is only for calls you dialed or answered with Telephony.
 627  *  Swap is only available for the voice calls.
 628  *
 629  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 630  * However it just means that the API request has been transfered to the CP successfully.
 631  * The actual operation result is being delivered in the corresponding event asynchronously.
 632  *
 633  * @par Notes:
 634  * During a call, user can place all active calls and accepts the other held call with this function.
 635  * If the terminal is not within a call, it will fail.
 636  *
 637  *
 638  * @par Sync (or) Async:
 639  * This is an Asynchronous API.
 640  *
 641  * @par Important Notes:
 642  *   - None.
 643  *
 644  * @warning
 645  * Do not use this function. This function is dedicated to the embedded call application only.
 646  * Please use its AUL interface instead of this.
 647  *
 648  * @param[in] CallHandle1
 649  *  - This is active call
 650  *
 651  * @param[in] CallHandle2
 652  *  - This is Held call
 653  *
 654  * @param [out] pRequestId
 655  *   - Unique identifier for a particular request.
 656  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 657  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 658  *
 659  * @par Async Response Message:
 660  * -
 661  *
 662  * @pre
 663  *  - Initialize Dbus connection with #tel_init
 664  *  - Register caller's application name with #tel_register_app_name
 665  *  - Register telephony events to listen
 666  *  - A event loop is running to listen events
 667  *  - None.
 668  *
 669  * @post
 670  *  - None.
 671  *
 672  * @return Return Type (int) \n
 673  * - 0 - indicating that the operation has completed successfully. \n
 674  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 675  *
 676  * @par Prospective Clients:
 677  * Embedded call application
 678  *
 679  * @code
 680  * #include <ITapiCall.h>
 681  *
 682  * int ret_status ;
 683  * unsigned int  pCallHandle1;
 684  * unsigned int  pCallHandle2;
 685  * int pRequestID=0;
 686  *
 687  * ret_status = tel_swap_call(pCallHandle1, pCallHandle2,&pRequestID); // swap call
 688  * @endcode
 689  *
 690  * @see None.
 691  *
 692  * @remarks
 693  * - None
 694  *
 695  *
 696  */
 697  int tel_swap_call(unsigned int CallHandle1, unsigned int CallHandle2, int * pRequestId);
 698
 699  /**
 700  *
 701  * @brief This function sends one or more DTMF digits during the call.
 702  *
 703  * @par Notes:
 704  * DTMF is abbreviation of Dual-tone-multi-frequency. It is used for telecommunication signaling
 705  * over telephone lines in the voice-frequency band between UE and other communications devices.
 706  * For example UE send DTMF tone to a server to choose options which the server provides.
 707  * If the UE is not within a call, this function will fail with error code. *
 708  *
 709  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 710  * However it just means that the API request has been transfered to the CP successfully.
 711  * The actual operation result is being delivered in the corresponding event asynchronously.
 712  *
 713  * @par Sync (or) Async:
 714  * This is an Asynchronous API.
 715  *
 716  * @par Important Notes:
 717  *  -There will be a single asynchronous notification for all the DTMF digits sent. If the users of this API need an asynchronous
 718  *    response for each DTMF digit then User has to call this API multiple times passing each single DTMF digit in pDtmfString.
 719  *
 720  * @warning
 721  * Do not use this function. This function is dedicated to the embedded call application only.
 722  * Please use its AUL interface instead of this.
 723  *
 724  *
 725  * @param[in] pDtmfString
 726  *  - A Null terminated DTMF string to be sent from MS.
 727  *
 728  * @param [out] pRequestId
 729  *   - Unique identifier for a particular request.
 730  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 731  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 732  *
 733  * @par Async Response Message:
 734  * - The event associated with this request is TAPI_EVENT_CALL_SEND_DTMF_CNF. Asynchronous return status
 735  *    is indicated by #TelCallCause_t and call handle is sent in the event data.
 736  *
 737  * @pre
 738  *  - Initialize Dbus connection with #tel_init
 739  *  - Register caller's application name with #tel_register_app_name
 740  *  - Register telephony events to listen
 741  *  - A event loop is running to listen events
 742  *  - Active call should be present.
 743  *
 744  * @post
 745  *  - None.
 746  *
 747  * @return Return Type (int) \n
 748  * - 0 - indicating that the operation has completed successfully. \n
 749  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 750  *
 751  * @par Prospective Clients:
 752  * Embedded call application
 753  *
 754  *
 755  * \image html CallDtmf.jpg
 756  * \image latex CallDtmf.jpg
 757  *
 758  * @code
 759  * #include <ITapiCall.h>
 760  *
 761  * int ret_status ;
 762  * unsigned int  pCallHandle;
 763  * int pRequestID=0;
 764  * char DtmfString[10] = {0, };
 765  * strcpy(DtmfString, "123456789");//Sample DTMF digits that need to be sent
 766  * ret_status= tel_send_call_dtmf(DtmfString,&pRequestID);
 767  * @endcode
 768  *
 769  *
 770  * @see None.
 771  *
 772  * @remarks
 773  * - None
 774  *
 775  *
 776  */
 777  int tel_send_call_dtmf(const char *pDtmfString, int * pRequestId);
 778
 779  /**
 780  *
 781  * @brief This function joins the given two calls (one call in active conversation state and other call in held state) into conference.
 782  *
 783  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 784  * However it just means that the API request has been transfered to the CP successfully.
 785  * The actual operation result is being delivered in the corresponding event asynchronously.
 786  *
 787  *
 788  * @par Sync (or) Async:
 789  * This is an Asynchronous API.
 790  *
 791  * @par Important Notes:
 792  *  - Call handle of an active call or held call will be made as MPTY-id, and the other call handle will join in a conference).
 793  *
 794  * @warning
 795  * Do not use this function. This function is dedicated to the embedded call application only.
 796  * Please use its AUL interface instead of this.
 797  *
 798  *
 799  * @param[in] CallHandle1
 800  *  - The unique handle can be either an active call or held call.
 801  *
 802  * @param[in] CallHandle2
 803  *  - Unique call handle.
 804  *
 805  * @param [out] pRequestId
 806  *   - Unique identifier for a particular request.
 807  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 808  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 809  *
 810  * @par Async Response Message:
 811  * - The event associated with this request is TAPI_EVENT_CALL_SETUPCONFERENCE_CNF. Asynchronous return
 812  *    status is indicated by #TelCallCause_t and call handle of the MPTY call is sent in the event data.
 813  *
 814  * @pre
 815  *  - Initialize Dbus connection with #tel_init
 816  *  - Register caller's application name with #tel_register_app_name
 817  *  - Register telephony events to listen
 818  *  - A event loop is running to listen events
 819  *  - For a Multiparty call or for joining two calls into conference, there should be one call in active state and another call
 820  *    in held state.
 821  *
 822  * @post
 823  *  - None.
 824  *
 825  * @return Return Type (int) \n
 826  * - 0 - indicating that the operation has completed successfully. \n
 827  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 828  *
 829  * @par Prospective Clients:
 830  * Embedded call application
 831  *
 832  * @see tel_split_call
 833  *
 834  * @code
 835  * #include <ITapiCall.h>
 836  *
 837  * int ret_status ;
 838  * unsigned int  pCallHandle1;
 839  * unsigned int  pCallHandle2;
 840  * int pRequestID=0;
 841  *
 842  * ret_status= tel_join_call(pCallHandle1, pCallHandle2,&pRequestID); // call join
 843  * @endcode
 844  *
 845  * @remarks
 846  * - None
 847  *
 848  *
 849  *
 850  *
 851  */
 852  int tel_join_call(unsigned int CallHandle1, unsigned int CallHandle2, int * pRequestId);
 853
 854  /**
 855  *
 856  * @brief This function triggers to splits a private call from multiparty call. This API allows creating a private communication
 857  *          with one of remote parties in a multiparty session. TAPI client application has to pass the call handle which needs
 858  *          to split from the multiparty call.
 859  *
 860  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 861  * However it just means that the API request has been transfered to the CP successfully.
 862  * The actual operation result is being delivered in the corresponding event asynchronously.
 863  *
 864  *
 865  * @par Sync (or) Async:
 866  * This is an Asynchronous API.
 867  *
 868  * @par Important Notes:
 869  *  - The list of call handles present in the conference call is retrieved using #tel_get_call_conf_list API
 870  *
 871  * @warning
 872  * Do not use this function. This function is dedicated to the embedded call application only.
 873  * Please use its AUL interface instead of this.
 874  *
 875  *
 876  * @param[in] CallHandle
 877  *  - Handle of call to be made private. Call handle referring to the call that is to be split from the conference
 878  *     (call to be made private).
 879  *
 880  * @param [out] pRequestId
 881  *   - Unique identifier for a particular request.
 882  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 883  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 884  *
 885  * @par Async Response Message:
 886  * - The event associated with this request is TAPI_EVENT_CALL_SPLITCONFERENCE_CNF. Asynchronous return status
 887  *    is indicated by #TelCallCause_t and call handle for the split call is sent in the event data.
 888  *
 889  * @pre
 890  *  - Initialize Dbus connection with #tel_init
 891  *  - Register caller's application name with #tel_register_app_name
 892  *  - Register telephony events to listen
 893  *  - A event loop is running to listen events
 894  *  - Call should be in multiparty conference call.
 895  *
 896  * @post
 897  *  - Split call will be the active call and the conference will be held call.
 898  *
 899  * @return Return Type (int) \n
 900  * - 0 - indicating that the operation has completed successfully. \n
 901  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 902  *
 903  * @par Prospective Clients:
 904  * Embedded call application
 905  *
 906  * @see tel_join _call
 907  *
 908  * @code
 909  * #include <ITapiCall.h>
 910  *
 911  * int ret_status ;
 912  * unsigned int  pCallHandle;
 913  * int pRequestID=0;
 914  *
 915  * ret_status= tel_split_call(pCallHandle,&pRequestID); // call split
 916  * @endcode
 917  *
 918  * @remarks
 919  * - None
 920  *
 921  *
 922  *
 923  *
 924  */
 925  int tel_split_call(unsigned int CallHandle, int * pRequestId);
 926
 927  /**
 928  *
 929  * @brief Get the current calling line identification number.
 930  *
 931  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 932  * However it just means that the API request has been transfered to the CP successfully.
 933  * The actual operation result is being delivered in the corresponding event asynchronously.
 934  *
 935  * @par Notes:
 936  * If the USIM card has multiple number, an user can choose which number he use.
 937  * For example, a line is for private, the other line is for business.
 938  * Using this function, user can get information about which line is currently active.
 939  *
 940  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 941  * However it just means that the API request has been transfered to the CP successfully.
 942  * The actual operation result is being delivered in the corresponding event asynchronously.
 943  *
 944  * @par Sync (or) Async:
 945  * This is an Asynchronous API.
 946  *
 947  * @par Important Notes:
 948  *  NONE
 949  *
 950  * @warning
 951  * Do not use this function. This function is dedicated to the embedded call application only.
 952  * Please use its AUL interface instead of this.
 953  *
 954  * @param [out] ptr_active_line
 955  *    current active line id.
 956  *
 957  * @param [out] pRequestId
 958  *   - Unique identifier for a particular request.
 959  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
 960  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
 961  *
 962  * @pre
 963  *  - Initialize Dbus connection with #tel_init
 964  *  - Register caller's application name with #tel_register_app_name
 965  *  - Register telephony events to listen
 966  *  - A event loop is running to listen events
 967  *
 968  * @post
 969  *  - None.
 970  *
 971  * @return Return Type (int) \n
 972  * - 0 - indicating that the operation has completed successfully. \n
 973  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
 974  *
 975  * @par Prospective Clients:
 976  * Embedded call application
 977  *
 978  * @see tel_set_call_act_line
 979  *
 980  * @code
 981  * #include <ITapiCall.h>
 982  *
 983  * int  pRequestID=0;
 984  * ret_status= tel_get_call_act_line(&pRequestID); // get call active line
 985  * @endcode
 986  *
 987  * @remarks
 988  * - None
 989  *
 990  *
 991  */
 992  int tel_get_call_act_line( int * pRequestId);
 993
 994  /**
 995  *
 996  * @brief Set the current calling line identification number.
 997  *
 998  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 999  * However it just means that the API request has been transfered to the CP successfully.
1000  * The actual operation result is being delivered in the corresponding event asynchronously.
1001  *
1002  *
1003  * @par Sync (or) Async:
1004  * This is an Asynchronous API.
1005  *
1006  * @par Important Notes:
1007  *  NONE
1008  *
1009  * @warning
1010  * Do not use this function. This function is dedicated to the embedded call application only.
1011  * Please use its AUL interface instead of this.
1012  *
1013  *
1014  * @param[in] active_line
1015  *  - calling line identification
1016  *
1017  * @param[out] pRequestId
1018  *   - Unique identifier for a particular request.
1019  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1020  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1021  *
1022  * @pre
1023  *  - Initialize Dbus connection with #tel_init
1024  *  - Register caller's application name with #tel_register_app_name
1025  *  - Register telephony events to listen
1026  *  - A event loop is running to listen events
1027  *
1028  * @post
1029  *  - None.
1030  *
1031  * @return Return Type (int) \n
1032  * - 0 - indicating that the operation has completed successfully. \n
1033  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1034  *
1035  * @par Prospective Clients:
1036  * Embedded call application
1037  *
1038  * @see tel_get_call_act_line
1039  *
1040  * @code
1041  * #include <ITapiCall.h>
1042  *
1043  * int ret_status ;
1044  * TelCallActiveLine_t g_curLine =TAPI_CALL_ACTIVE_LINE1;
1045  * TelCallActiveLine_t active_line ;
1046  * int  pRequestID=0;
1047  *
1048  * ret_status = tel_set_call_act_line (g_curLine,&pRequestID); // set call active line
1049  * @endcode
1050  *
1051  * @remarks
1052  * - None
1053  *
1054  *
1055  */
1056  int tel_set_call_act_line(TelCallActiveLine_t active_line, int * pRequestId);
1057
1058  /**
1059  *
1060  * @brief This function triggers to do an explicit call transfer by connecting the two parties where in one party being
1061  *          active (active state) and another party being held (held state).
1062  *
1063  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1064  * However it just means that the API request has been transfered to the CP successfully.
1065  * The actual operation result is being delivered in the corresponding event asynchronously.
1066  *
1067  * @par Notes:
1068  * The ECT supplementary service enables the served mobile subscriber (subscriber A) who has two calls ,
1069  * each of which can be an incoming or outgoing call, to connect the other parties in the two calls
1070  * and release the served mobile subscribers own connection.
1071  * Prior to transfer, the connection shall have been established on the call
1072  * between subscriber A and subscriber B. On the call between subscriber A and subscriber C,
1073  * either the connection shall have been established prior to transfer, or, as a network option,
1074  * transfer can occur while subscriber C is being informed of the call
1075  * (i.e. the connection has not yet been established.)
1076  *
1077  *
1078  * @par Sync (or) Async:
1079  * This is an Asynchronous API.
1080  *
1081  * @par Important Notes:
1082  *  - None.
1083  *
1084  * @warning
1085  * Do not use this function. This function is dedicated to the embedded call application only.
1086  * Please use its AUL interface instead of this.
1087  *
1088  *
1089  * @param[in] CallHandle
1090  *  - Call handle of an active call.
1091  *
1092  * @param [out] pRequestId
1093  *   - Unique identifier for a particular request.
1094  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1095  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1096  *
1097  * @par Async Response Message:
1098  * - The event associated with this request is TAPI_EVENT_CALL_TRANSFER_CNF. Asynchronous return status is
1099  *    indicated by #TelCallCause_t and call handle is sent in the event data. Call handle in event data is active
1100  *    call handle which is used in the #tel_exe_call_explicit_transfer request.
1101  *
1102  * @pre
1103  *  - In order to call transfer, Served mobile subscriber should have 2 calls in one in active state and another one Call
1104  *    in Held state.
1105  *
1106  * @post
1107  *  - When the request has been completed successfully, Call end indication will be sent to both the calls (active and held).
1108  *
1109  * @return Return Type (int) \n
1110  * - 0 - indicating that the operation has completed successfully. \n
1111  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1112  *
1113  * @par Prospective Clients:
1114  * Embedded call application
1115  *
1116  * @see None.
1117  *
1118  * @code
1119  * #include <ITapiCall.h>
1120  *
1121  * int ret_status ;
1122  * unsigned int  pCallHandle;//active call
1123  * int pRequestID=0;
1124  *
1125  * ret_status= tel_exe_call_explicit_transfer (pCallHandle,&pRequestID); // explicit transfer
1126  * @endcode
1127  *
1128  * @remarks
1129  * -None
1130  *
1131  *
1132  */
1133  int tel_exe_call_explicit_transfer(unsigned int CallHandle, int * pRequestId);
1134
1135
1136 /**
1137  *
1138  * @brief This function gets status for the current call identified by Call Handle whenever application wants the call status. Call handle must be valid.
1139  *
1140  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1141  * However it just means that the API request has been transfered to the CP successfully.
1142  * The actual operation result is being delivered in the corresponding event asynchronously.
1143  *
1144  *
1145  * @par Sync (or) Async:
1146  * This is a Synchronous API.
1147  *
1148  * @par Important Notes:
1149  *   - None.
1150  *
1151  * @warning
1152  * Do not use this function. This function is dedicated to the embedded call application only.
1153  * Please use its AUL interface instead of this.
1154  *
1155  *
1156  * @param[in] CallHandle
1157  *  - Unique handle for referring the call.
1158  *
1159  * @param [out] pCallStatus
1160  *   - Call status information like destination number, call direction (MO or MT), call type (voice or data etc), whether
1161  *      the call is in conference state or not, present call state etc are returned through this parameter.
1162  *
1163  * @par Async Response Message:
1164  *   - None.
1165  *
1166  * @pre
1167  *  - Initialize Dbus connection with #tel_init
1168  *  - Register caller's application name with #tel_register_app_name
1169  *  - Register telephony events to listen
1170  *  - A event loop is running to listen events
1171  *
1172  * @post
1173  *  - None.
1174  *
1175  * @return Return Type (int) \n
1176  * - 0 - indicating that the operation has completed successfully. \n
1177  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1178  *
1179  * @par Prospective Clients:
1180  * Embedded call application
1181  *
1182  *
1183  *
1184  *
1185  * @code
1186  * #include <ITapiCall.h>
1187  *
1188  * int  ret_status ;
1189  * unsigned int CallHandle;
1190  * TelCallStatus_t      callStatus;
1191  *
1192  * ret_status= tel_get_call_status(CallHandle,&callStatus); // get call status info
1193  * @endcode
1194  *
1195  *
1196  * @see None.
1197  *
1198  * @remarks
1199  * - None
1200  *
1201  *
1202  */
1203
1204  int tel_get_call_status(unsigned int CallHandle, TelCallStatus_t * pCallStatus) ;
1205
1206
1207  /**
1208  *
1209  * @brief This function gets duration of the given call. This is a synchronous function. Duration is accounted from the moment
1210  *          the connection is established, i.e. call goes into active state for first time.
1211  *
1212  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1213  * However it just means that the API request has been transfered to the CP successfully.
1214  * The actual operation result is being delivered in the corresponding event asynchronously.
1215  *
1216  *
1217  * @par Sync (or) Async:
1218  * This is a Synchronous API.
1219  *
1220  * @par Important Notes:
1221  *   - None.
1222  *
1223  * @warning
1224  * Do not use this function. This function is dedicated to the embedded call application only.
1225  * Please use its AUL interface instead of this.
1226  *
1227  *
1228  * @param[in] CallHandle
1229  *  - Unique handle for referring the call.
1230  *
1231  * @param [out] pDurationInSecs
1232  *   - The total call duration in seconds from the call connecting time to the present time is returned through this parameter.
1233  *
1234  * @par Async Response Message:
1235  *  - None.
1236  *
1237  * @pre
1238  *  - Initialize Dbus connection with #tel_init
1239  *  - Register caller's application name with #tel_register_app_name
1240  *  - Register telephony events to listen
1241  *  - A event loop is running to listen events
1242  *
1243  * @post
1244  *  - None.
1245  *
1246  * @return Return Type (int) \n
1247  * - TAPI_API_SUCCESS - indicating that the operation has completed successfully. \n
1248  * - Else it will return failure and error code (Refer #TapiResult_t)
1249  *
1250  * @par Prospective Clients:
1251  * Embedded call application
1252  *
1253  *
1254  *
1255  *
1256  * @code
1257  * #include <ITapiCall.h>
1258  *
1259  * int ret_status ;
1260  * unsigned int CallHandle;
1261  * unsigned int duration;
1262  *
1263  * ret_status= tel_get_call_duration(CallHandle,&duration); // get call duration
1264  * @endcode
1265  *
1266  *
1267  * @see None.
1268  *
1269  * @remarks
1270  * - None
1271  *
1272  *
1273  */
1274  int tel_get_call_duration(unsigned int CallHandle, unsigned int * pDurationInSecs) ;
1275
1276  /**
1277   *@brief Deflect the incoming call to other subscriber
1278   *
1279   * If informed about an incoming call this call may be redirected to an another destination by
1280   * entering the destination Number. The cleint spcifies the dstiantion number to which the current
1281   * incoming call needs to be redirected is specifed via info argument.
1282   *
1283   *
1284   * @par Sync (or) Async:
1285   * This is an Asynchronous API.
1286   *
1287   * @par Important Notes:
1288   *  - None.
1289   *
1290   * @warning
1291   * Do not use this function. This function is dedicated to the embedded call application only.
1292   * Please use its AUL interface instead of this.
1293   *
1294   * @param[in] CallHandle
1295   *  - This is incoming call handle
1296   *
1297   * @param[out] deflect_info
1298   *  - Destination Number
1299   *
1300   * @param [out] pRequestID
1301   *   - Unique identifier for a particular request.
1302   *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1303   *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1304   *
1305   * @par Async Response Message:
1306   * -
1307   *
1308   * @pre
1309   *  - Initialize Dbus connection with #tel_init
1310   *  - Register caller's application name with #tel_register_app_name
1311   *  - Register telephony events to listen
1312   *  - A event loop is running to listen events
1313   *
1314   * @post
1315   *  - None.
1316   *
1317   * @return Return Type (int) \n
1318   * - 0 indicating that the operation has completed successfully. \n
1319   * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1320   *
1321   * @par Prospective Clients:
1322   * Embedded call application
1323   *
1324   * @remarks
1325   * - None
1326   *
1327   * @code
1328   * #include <ITapiCall.h>
1329   * #include <TelCall.h>
1330   *
1331   * unsigned int call_handle;
1332   * TelCallDeflectDstInfo_t deflect_info;
1333   * int req_id;
1334   *
1335   * tel_deflect_call( call_handel, &deflect_info, req_id); // call deflect
1336   *
1337   * @endcode
1338   *
1339   * @see None.
1340   *
1341   * @remarks
1342   * - None
1343   *
1344   */
1345  int tel_deflect_call(unsigned int CallHandle, const TelCallDeflectDstInfo_t *deflect_info, int *pRequestID);
1346
1347
1348   /**
1349   *
1350   * @brief Activate Call Completion to a Busy Subscriber.
1351   *
1352   * @par Notes:
1353   * When subscriber A encounters a Network Determined User Busy (NDUB) destination B,
1354   * subscriber A can request the CCBS supplementary service (i.e. activate a CCBS Request against destination B).
1355   * The network will then monitor the wanted destination B for becoming idle.
1356   * When the wanted destination B becomes idle, then the network will wait a short time
1357   * in order to allow destination B to make an outgoing call.
1358   * If destination B does not make any outgoing call within this time,
1359   * then the network shall automatically recall subscriber A.
1360   * When subscriber A accepts the CCBS recall, within a defined time, then the network will automatically
1361   * generate a CCBS call to destination B.
1362   *
1363   * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1364   * However it just means that the API request has been transfered to the CP successfully.
1365   * The actual operation result is being delivered in the corresponding event asynchronously.
1366   *
1367   * @par Sync (or) Async:
1368   * This is an Asynchronous API.
1369   *
1370   * @par Important Notes:
1371   *   - None.
1372   *
1373   * @warning
1374   * Do not use this function. This function is dedicated to the embedded call application only.
1375   * Please use its AUL interface instead of this.
1376   *
1377   * @param [in] CallHandle
1378   *  - Handle of the call.
1379   *
1380   * @param [out] pRequestID
1381   *   - Unique identifier for a particular request.
1382   *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1383   *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1384   *
1385   * @par Async Response Message:
1386   * -
1387   *
1388   * @pre
1389  *  - Initialize Dbus connection with #tel_init
1390  *  - Register caller's application name with #tel_register_app_name
1391  *  - Register telephony events to listen
1392  *  - A event loop is running to listen events
1393   *
1394   * @post
1395   *  - None.
1396   *
1397   * @return Return Type (int) \n
1398   * - 0 - indicating that the operation has completed successfully. \n
1399   * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1400   *
1401   * @par Prospective Clients:
1402   * Embedded call application
1403   *
1404   * @code
1405   * #include <ITapiCall.h>
1406   *
1407   * int ret;
1408   * unsigned int call_handle;
1409   * int req_id;
1410   *
1411   * ret = tel_activate_call_ccbs( call_handle, &req_id ); // ccbs activate
1412   * @endcode
1413   *
1414  *
1415  * @see None.
1416  *
1417  * @remarks
1418  * - None
1419  *
1420   */
1421  int tel_activate_call_ccbs(unsigned int CallHandle, int * pRequestID);
1422
1423
1424  /**
1425  * @brief This is a synchronous function returns all call handles within the given conference call.
1426  *
1427  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1428  * However it just means that the API request has been transfered to the CP successfully.
1429  * The actual operation result is being delivered in the corresponding event asynchronously.
1430  *
1431  * @par Sync (or) Async:
1432  * This is a Synchronous API.
1433  *
1434  * @par Important Notes:
1435  *  - Call should be a Multi-party conference call in order to return actual no of calls and call handles in the conference calls.
1436  *
1437  * @warning
1438  * Do not use this function. This function is dedicated to the embedded call application only.
1439  * Please use its AUL interface instead of this.
1440  *
1441  *
1442  * @param[in] CallHandle
1443  *  - Handle of call which is associated with the conference.
1444  *
1445  * @param [out] pCallList
1446  *   - list of call joined in the conference call. In case there is no active conference. The list will be zero and
1447  *      number of calls parameter value will also be zero. Maximum number of calls in a conference can be up to 5
1448  *      (Based on 3GPP TS 22.084). Memory allocation for call list is integer array of size 5.
1449  *
1450  * @param [out] pNoOfCalls
1451  *   - Number of the calls present in conference.
1452  *
1453  * @par Async Response Message:
1454  *  -None.
1455  *
1456  * @pre
1457  *  - Initialize Dbus connection with #tel_init
1458  *  - Register caller's application name with #tel_register_app_name
1459  *  - Register telephony events to listen
1460  *  - A event loop is running to listen events
1461  *
1462  * @post
1463  *  -None.
1464  *
1465  * @return Return Type (int) \n
1466  * - 0 - indicating that the operation has completed successfully. \n
1467  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1468  *
1469  * @par Prospective Clients:
1470  * Embedded call application
1471  *
1472  * @code
1473  * #include <ITapiCall.h>
1474  *
1475  * int ret_status ;
1476  * unsigned int CallHandle;
1477  * unsigned int  callList[5];
1478  * int  noOfCalls;
1479  *
1480  * ret_status= tel_get_call_conf_list(CallHandle, callList, &noOfCalls); // get conference call list
1481  * @endcode
1482  *
1483  * @see tel_join_call
1484  *
1485  * @remarks
1486  * - None
1487  *
1488  *
1489  */
1490  int tel_get_call_conf_list (unsigned int CallHandle, const unsigned int * pCallList, int * pNoOfCalls);
1491
1492
1493  /**
1494  *
1495  * @brief This function gets voice privacy option mode in phone(CDMA only).
1496  *
1497  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1498  * However it just means that the API request has been transfered to the CP successfully.
1499  * The actual operation result is being delivered in the corresponding event asynchronously.
1500  *
1501  * @par Sync (or) Async:
1502  * This is a Asynchronous API.
1503  *
1504  * @par Important Notes:
1505  *   - None.
1506  *
1507  * @warning
1508  * Do not use this function. This function is dedicated to the embedded call application only.
1509  * Please use its AUL interface instead of this.
1510  *
1511  *
1512  * @param[in] PrivacyType
1513  * - Privacy Type.
1514  *
1515  * @param [out] pRequestID
1516  *   - Unique identifier for a particular request.
1517  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1518  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1519  *
1520  *
1521  * @par Async Response Message:
1522  * - The event associated with this request is TAPI_EVENT_CALL_GET_PRIVACYMODE_CNF. Asynchronous return status
1523  *   is indicated by #TelCallCause_t. #TelCallPrivacyMode_t is included in this event.
1524  *
1525  *
1526  * @pre
1527  *  - Initialize Dbus connection with #tel_init
1528  *  - Register caller's application name with #tel_register_app_name
1529  *  - Register telephony events to listen
1530  *  - A event loop is running to listen events
1531  *
1532  * @post
1533  *  - None.
1534  *
1535  * @return Return Type (int) \n
1536  * - 0 - indicating that the operation has completed successfully. \n
1537  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1538  *
1539  * @par Prospective Clients:
1540  * Embedded call application
1541  *
1542  *
1543  *
1544  * @code
1545  * #include <ITapiCall.h>
1546  *
1547  * Int ReqId=-1;
1548  * int ret_status = -1;
1549  * int api_err;
1550  * TelCallPrivacyType_t privacyType;
1551  * privacyType=TAPI_CALL_PRIVACY_TYPE_MS;
1552  * ret_status =tel_get_call_privacy_mode (privacyType,&req_id); // get call privacy_mode
1553  * @endcode
1554  *
1555  *
1556  * @see None.
1557  *
1558  * @remarks
1559  * - None
1560  *
1561  *
1562  */
1563  int tel_get_call_privacy_mode(TelCallPrivacyType_t PrivacyType, int * pRequestID);
1564
1565
1566  /**
1567  *
1568  * @brief This function sets voice privacy option mode in phone. It is available only where call exists(CDMA only).
1569  *
1570  *
1571  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1572  * However it just means that the API request has been transfered to the CP successfully.
1573  * The actual operation result is being delivered in the corresponding event asynchronously.
1574  *
1575  * @par Sync (or) Async:
1576  * This is a Asynchronous API.
1577  *
1578  * @par Important Notes:
1579  *   - None.
1580  *
1581  * @warning
1582  * Do not use this function. This function is dedicated to the embedded call application only.
1583  * Please use its AUL interface instead of this.
1584  *
1585  *
1586  * @param[in] PrivacyInfo
1587  * - voice privacy option mode(ENHANCED or STANDARD)
1588  *
1589  *
1590  * @param [out] pRequestID
1591  *   - Unique identifier for a particular request.
1592  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1593  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1594  *
1595  *
1596  * @par Async Response Message:
1597  * - The event associated with this request is TAPI_EVENT_CALL_SET_PRIVACYMODE_CNF. Asynchronous return status
1598  *    is indicated by #TelCallCause_t.
1599  *
1600  *
1601  * @pre
1602  *  - Initialize Dbus connection with #tel_init
1603  *  - Register caller's application name with #tel_register_app_name
1604  *  - Register telephony events to listen
1605  *  - A event loop is running to listen events
1606  *
1607  * @post
1608  *  - None.
1609  *
1610  * @return Return Type (int) \n
1611  * - 0 - indicating that the operation has completed successfully. \n
1612  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1613  *
1614  * @par Prospective Clients:
1615  * Embedded call application
1616  *
1617  *
1618  *
1619  * @code
1620  * #include <ITapiCall.h>
1621  *
1622  * int ReqId=-1;
1623  * int ret_status = -1;
1624  * int api_err;
1625  * TelCallPrivacyMode_t pPrivacyMode_info={0,};
1626  * pPrivacyMode_info = TAPI_CALL_PRIVACY_MODE_STANDARD;
1627  *
1628  * ret_status = tel_set_call_privacy_mode (pPrivacyMode_info,&reqId); // set call privacy mode
1629  * @endcode
1630  *
1631  * @see None.
1632  *
1633  * @remarks
1634  * - None
1635  *
1636  *
1637  */
1638  int tel_set_call_privacy_mode(TelCallVoicePrivacyInfo_t PrivacyInfo, int * pRequestID);
1639
1640
1641 /**
1642  *
1643  * @brief This function requests to send a Flash with Information Message(CDMA only).
1644  *
1645  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1646  * However it just means that the API request has been transfered to the CP successfully.
1647  * The actual operation result is being delivered in the corresponding event asynchronously.
1648  *
1649  *
1650  * @par Sync (or) Async:
1651  * This is a Asynchronous API.
1652  *
1653  * @par Important Notes:
1654  *   - None.
1655  *
1656  * @warning
1657  * Do not use this function. This function is dedicated to the embedded call application only.
1658  * Please use its AUL interface instead of this.
1659  *
1660  *
1661  * @param[in] pDialNumber
1662  * - this is the calling number for 3 way call. But in the call waiting, this param should be NULL.
1663  *
1664  *
1665  * @param [out] pRequestID
1666  *   - Unique identifier for a particular request.
1667  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1668  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1669  *
1670  *
1671  * @par Async Response Message:
1672  * - The event associated with this request is TAPI_EVENT_CALL_FLASHINFO_CNF. Asynchronous return status
1673  *    is indicated by #TelCallCause_t.
1674  *
1675  *
1676  * @pre
1677  *  - None.
1678  *
1679  * @post
1680  *  - None.
1681  *
1682  * @return Return Type (int) \n
1683  * - 0 - indicating that the operation has completed successfully. \n
1684  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1685  *
1686  * @par Prospective Clients:
1687  * Embedded call application
1688  *
1689  * @code
1690  * #include <ITapiCall.h>
1691  *
1692  * int ret_status = -1;
1693  * int api_err;
1694  * char const * const pDialNumber = "9999900000";
1695  * ret_status = tel_exe_call_flash_info(pDialNumber,&reqId); // call flash info
1696  * @endcode
1697  *
1698  * @see None.
1699  *
1700  * @remarks
1701  * - None
1702  *
1703  *
1704  */
1705  int tel_exe_call_flash_info(const char *pDialNumber, int * pRequestID);
1706
1707
1708 /**
1709  *
1710  * @brief This function requests to exit emergency call mode(CDMA only).
1711  *
1712  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1713  * However it just means that the API request has been transfered to the CP successfully.
1714  * The actual operation result is being delivered in the corresponding event asynchronously.
1715  *
1716  * @par Sync (or) Async:
1717  * This is a Asynchronous API.
1718  *
1719  * @par Important Notes:
1720  *   - None.
1721  *
1722  * @warning
1723  * Do not use this function. This function is dedicated to the embedded call application only.
1724  * Please use its AUL interface instead of this.
1725  *
1726  * @param[out] pRequestID
1727  *   - Unique identifier for a particular request.
1728  *   Request Id value can be any value from 0 to 255 if the API is returned successfully
1729  *   -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1730  *
1731  * @par Async Response Message:
1732  * - The event associated with this request is TAPI_EVENT_CALL_EXIT_EMERGENCYMODE_CNF. Asynchronous return status
1733  *    is indicated by #TelCallCause_t.
1734  *
1735  * @pre
1736  *  - current state is emergency callback mode.
1737  *
1738  * @post
1739  *  - None.
1740  *
1741  * @return Return Type (int) \n
1742  * - 0 - indicating that the operation has completed successfully. \n
1743  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1744  *
1745  * @par Prospective Clients:
1746  * Embedded call application
1747  *
1748  * @code
1749  * #include <ITapiCall.h>
1750  *
1751  * int req_id;
1752  * int ret;
1753  *
1754  * ret = tel_exit_call_emergency_mode ( &req_id ); // emergency call
1755  *
1756  * @endcode
1757  *
1758  * @see None.
1759  *
1760  * @remarks
1761  * - None
1762  *
1763  *
1764  */
1765  int tel_exit_call_emergency_mode(int * pRequestID);
1766
1767
1768 /**
1769  *
1770  * @brief This function is used for querying the information about a call time and call count.
1771  *
1772  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1773  * However it just means that the API request has been transfered to the CP successfully.
1774  * The actual operation result is being delivered in the corresponding event asynchronously.
1775  *
1776  * @par Sync (or) Async:
1777  * This is a Asynchronous API.
1778  *
1779  * @par Important Notes:
1780  *   - None.
1781  *
1782  * @warning
1783  * Do not use this function. This function is dedicated to the embedded call application only.
1784  * Please use its AUL interface instead of this.
1785  *
1786  *
1787  * @param[in] req_mask
1788  * - call time request type mask.
1789  *
1790  * @param[out] pRequestID
1791  *   - Unique identifier for a particular request.
1792  *   - Request Id value can be any value from 0 to 255 if the API is returned successfully
1793  *   - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1794  *
1795  *
1796  * @par Async Response Message:
1797  * - The event associated with this request is TAPI_EVENT_CALL_GET_CALL_TIME_CNF. Asynchronous return status
1798  *    is indicated by #TelCallCause_t.
1799  *
1800  *
1801  * @pre
1802  *  - None.
1803  *
1804  * @post
1805  *  - None.
1806  *
1807  * @return Return Type (int) \n
1808  * - 0 - indicating that the operation has completed successfully. \n
1809  * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1810  *
1811  * @par Prospective Clients:
1812  * Embedded call application
1813  *
1814  * @code
1815  * #include <ITapiCall.h>
1816  *
1817  * int ret_status = -1;
1818  * int api_err;
1819  * TelCallTimeMaskType_t mask_byte1 = {0,};
1820  * TelCallTimeMaskType_t  mask_byte2 = {0,};
1821  * unsigned short mask_type;
1822  * mask_byte1 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_CNT;  //masking call type
1823  * mask_byte2 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_TIME;
1824  *
1825  * mask_type = mask_byte1;
1826  * mask_type << 8;
1827  * mask_type = mask_byte2;
1828  *
1829  * ret_status = tel_get_call_time(mask_type,&reqId);
1830  *
1831  * @endcode
1832  *
1833  * @see None.
1834  *
1835  * @remarks
1836  * - None
1837  *
1838  *
1839  */
1840  int tel_get_call_time(unsigned short req_mask, int * pRequestID);
1841
1842
1843 #ifdef __cplusplus
1844 }
1845 #endif
1846
1847 #endif  /* _ITAPI_CALL_H_ */
1848
1849  /**
1850 * @}
1851 */