mobile/include/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 (TapiHandle *handle, voice / video ) is possible at any given time. @n
  37  */
  38
  39 #ifndef _ITAPI_CALL_H_
  40 #define _ITAPI_CALL_H_
  41
  42 #include <tapi_common.h>
  43 #include <TelCall.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 (TapiHandle *handle, or) Async:
  60  * This is an Asynchronous API.
  61  *
  62  * @par Important Notes:
  63  * - If call to tel_exe_call_mo(TapiHandle *handle, ) 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  *   (TapiHandle *handle, 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 (TapiHandle *handle, 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  *
  81  * @param [in] handle
  82  * - handle from tel_init()
  83  *
  84  * @param[in] pParams
  85  * - #TelCallSetupParams_t contains the CallType(TapiHandle *handle, whether it is a voice call or data call etc) and number.
  86  *
  87  * @param[out] pCallHandle
  88  * - Unique handle for referring the call
  89  *
  90  * @param [in] callback
  91  *   - To register callback function for result of this function.
  92  *
  93  * @param [in] user_data
  94  *   - user data for user specification
  95  *
  96  * @par Async Response Message:
  97  * TAPI_EVENT_CALL_SETUP_CNF is sent to the application when the lower layers get the call originate response.
  98  * Asynchronous return status is indicated by #TelCallCause_t and call handle is sent in the event data.
  99  * Various asynchronous indications are described in the unsolicited notifications section . [Refer, \ref page8]
 100  *
 101  * @pre
 102  * - Initialize Dbus connection with #tel_init
 103  * - Register caller's application name with #tel_register_app_name
 104  * - Register telephony events to listen
 105  * - A event loop is running to listen events
 106  *
 107  * @post
 108  * - None.
 109  *
 110  * @return Return Type (TapiHandle *handle, int) \n
 111  * - 0 - indicating that the operation has completed successfully. \n
 112  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 113  *
 114  * @par Prospective Clients:
 115  * Embedded call application
 116  *
 117  * @see tel_exe_call_mo tel_answer_call tel_release_call
 118  * \image html CallSetup.jpg
 119  * \image latex CallSetup.jpg
 120  *
 121  * @code
 122  * #include <ITapiCall.h>
 123  *
 124  * int ret_status =0;
 125  * unsigned int pCallHandle;
 126  * int pRequestID=0;
 127  * TelCallSetupParams_t pParams;
 128  *
 129  * char normal[16] = "1234";//Called party number
 130  * memset(TapiHandle *handle, &pParams, 0, sizeof(TapiHandle *handle, TelCallSetupParams_t), tapi_response_cb callback, void *user_data);
 131  * pParams.CallType = TAPI_CALL_TYPE_VOICE;
 132  * strcpy(TapiHandle *handle, pParams.szNumber,normal, tapi_response_cb callback, void *user_data);
 133  *
 134  * ret_status = tel_exe_call_mo (TapiHandle *handle, &pParams,&pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // outgoing call
 135  * @endcode
 136  *
 137  * @remarks
 138  * - None
 139  *
 140  *
 141  */
 142 int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data);
 143
 144  /**
 145  * @brief This function is used to answer the incoming call by accepting or rejecting the call.
 146  *
 147  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 148  * However it just means that the API request has been transfered to the CP successfully.
 149  * The actual operation result is being delivered in the corresponding event asynchronously.
 150  *
 151  * @par Sync (TapiHandle *handle, or) Async:
 152  * This is an Asynchronous API.
 153  *
 154  * @par Important Notes:
 155  * - None.
 156  *
 157  * @warning
 158  * Do not use this function. This function is dedicated to the embedded call application only.
 159  * Please use its AUL interface
 160  *
 161  *
 162  * @param [in] handle
 163  * - handle from tel_init()
 164  *
 165  * @param[in] CallHandle
 166  * - This is the unique handle for referring the call. This call handle is available to Application through incoming call
 167  *  (TapiHandle *handle, TAPI_EVENT_CALL_INCOM_IND) event.
 168  *
 169  * @param[in] AnsType
 170  * - Answer type - accept / reject / replace / hold and accept. but, for CDMA, only accept is allowed.
 171  *
 172  * @param [in] callback
 173  *   - To register callback function for result of this function.
 174  *
 175  * @param [in] user_data
 176  *   - user data for user specification
 177  *
 178  * @par Async Response Message:
 179  * - The event associated with this request is TAPI_EVENT_CALL_ANSWER_CNF. Asynchronous return status is
 180  *  indicated by #TelCallCause_t and call handle is sent in the event data.
 181  * - TAPI_EVENT_CALL_CONNECTED_IND / TAPI_EVENT_CALL_END_IND event will be notified in case of call is accepted/rejected.
 182  *
 183  * @pre
 184  * - Initialize Dbus connection with #tel_init
 185  * - Register caller's application name with #tel_register_app_name
 186  * - Register telephony events to listen
 187  * - A event loop is running to listen events
 188  * - Call associated with call handle should be TAPI_CALL_STATE_INCOM state otherwise the API fails and there can be a
 189  *   maximum of 1 existing call.
 190  *
 191  * @post
 192  * - None.
 193  *
 194  * @return Return Type (TapiHandle *handle, int) \n
 195  * - 0 - indicating that the operation has completed successfully. \n
 196  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 197  *
 198  * @par Prospective Clients:
 199  * Embedded call application
 200  *
 201  * @see tel_exe_call_mo tel_release_call
 202  *
 203  * \image html CallIncoming.jpg
 204  * \image latex CallIncoming.jpg
 205  *
 206  * @code
 207  * #include <ITapiCall.h>
 208  *
 209  * int ret_status ;
 210  * unsigned int pCallHandle;
 211  * int pRequestID=0;
 212  *
 213  * ret_status = tel_answer_call (TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call answer
 214  * @endcode
 215  *
 216  * @remarks
 217  * - None
 218  *
 219  *
 220  * @remarks
 221  * - None
 222  *
 223  *
 224  */
 225 int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data);
 226
 227  /**
 228  *
 229  * @brief This function releases the call identified by Call Handle irrespective of call is hold or active state.
 230  * It is used when releasing specific active call in multiparty call.
 231  *
 232  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 233  * However it just means that the API request has been transfered to the CP successfully.
 234  * The actual operation result is being delivered in the corresponding event asynchronously.
 235  *
 236  *
 237  * @par Sync (TapiHandle *handle, or) Async:
 238  * This is an Asynchronous API.
 239  *
 240  * @par Important Notes:
 241  * - In case of MPTY Call handle, Call end event is returned for each call in MPTY.
 242  *
 243  * @warning
 244  * Do not use this function. This function is dedicated to the embedded call application only.
 245  * Please use its AUL interface
 246  *
 247  *
 248  * @param [in] handle
 249  * - handle from tel_init()
 250  *
 251  * @param[in] CallHandle
 252  * - Unique handle for referring the call.
 253  *
 254  * @param [in] callback
 255  *   - To register callback function for result of this function.
 256  *
 257  * @param [in] user_data
 258  *   - user data for user specification
 259  *
 260  * @par Async Response Message:
 261  * - The event associated with this request is TAPI_EVENT_CALL_RELEASE_CNF and Asynchronous return status
 262  *  is indicated by #TelCallCause_t and call handle for the released call is sent in the event data..
 263  *
 264  * - The event TAPI_EVENT_CALL_END_IND_IND is received as final asynchronous response and the associated data is #TelCallEndInfo_t.
 265  *  Asynchronous return status is indicated by #TelCallCause_t.
 266  *
 267  * @pre
 268  * - Initialize Dbus connection with #tel_init
 269  * - Register caller's application name with #tel_register_app_name
 270  * - Register telephony events to listen
 271  * - A event loop is running to listen events
 272  * - Call handle should be valid and there should be an existing call in Active/hold state.
 273  *
 274  * @post
 275  * - None.
 276  *
 277  * @return Return Type (TapiHandle *handle, int) \n
 278  * - 0 - indicating that the operation has completed successfully. \n
 279  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 280  *
 281  * @par Prospective Clients:
 282  * Embedded call application
 283  *
 284  * @see tel_exe_call_mo tel_answer_call tel_release_call_all tel_release_call_all_active
 285  *
 286  * @code
 287  * #include <ITapiCall.h>
 288  *
 289  * int ret_status ;
 290  * unsigned int pCallHandle;
 291  * int pRequestID=0;
 292  *
 293  * ret_status = tel_release_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call release
 294  * @endcode
 295  *
 296  *
 297  * @remarks
 298  * - None
 299  *
 300  *
 301  */
 302 int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data);
 303
 304
 305  /**
 306  *
 307  * @brief This function puts the given call on hold. The call identified by Call Handle should be in active state.
 308  *
 309  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 310  * However it just means that the API request has been transfered to the CP successfully.
 311  * The actual operation result is being delivered in the corresponding event asynchronously.
 312  *
 313  *
 314  * @par Sync (TapiHandle *handle, or) Async:
 315  * This is an Asynchronous API.
 316  *
 317  * @par Important Notes:
 318  * - Call duration for the call will be calculated from the time call has been connected until call is released,
 319  *  i.e. Time duration during the call on hold will also be counted.
 320  *
 321  * @warning
 322  * Do not use this function. This function is dedicated to the embedded call application only.
 323  * Please use its AUL interface instead of this.
 324  *
 325  *
 326  * @param [in] handle
 327  * - handle from tel_init()
 328  *
 329  * @param[in] CallHandle
 330  * - Unique handle for referring the call.
 331  *
 332  * @param [in] callback
 333  *   - To register callback function for result of this function.
 334  *
 335  * @param [in] user_data
 336  *   - user data for user specification
 337  *
 338  * @par Async Response Message:
 339  * - The event associated with this request is TAPI_EVENT_CALL_HOLD_CNF. Asynchronous return status is
 340  *  indicated by #TelCallCause_t and call handle is sent in the event data.
 341  *
 342  * @pre
 343  * - Initialize Dbus connection with #tel_init
 344  * - Register caller's application name with #tel_register_app_name
 345  * - Register telephony events to listen
 346  * - A event loop is running to listen events
 347  * - The call identified by the Call Handle should be in active state.
 348  *
 349  * @post
 350  * - None.
 351  *
 352  * @return Return Type (TapiHandle *handle, int) \n
 353  * - 0 - indicating that the operation has completed successfully. \n
 354  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 355  *
 356  * @par Prospective Clients:
 357  * Embedded call application
 358  *
 359  * @code
 360  * #include <ITapiCall.h>
 361  *
 362  * int ret_status ;
 363  * unsigned int pCallHandle;//HANDLE OF AN ACTIVE CALL
 364  * int pRequestID=0;
 365  *
 366  * ret_status = tel_hold_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // hold call
 367  * @endcode
 368  *
 369  *
 370  * @see tel_retrieve_call
 371  *
 372  * @remarks
 373  * - None
 374  *
 375  *
 376  */
 377  int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
 378
 379  /**
 380  *
 381  * @brief This function retrieves the held call. The call identified by Call Handle must be in held state.
 382  *
 383  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 384  * However it just means that the API request has been transfered to the CP successfully.
 385  * The actual operation result is being delivered in the corresponding event asynchronously.
 386  *
 387  *
 388  * @par Sync (TapiHandle *handle, or) Async:
 389  * This is an Asynchronous API.
 390  *
 391  * @par Important Notes:
 392  * - Call duration for the call will be calculated from the moment call has been connected until call is released.
 393  *
 394  * @warning
 395  * Do not use this function. This function is dedicated to the embedded call application only.
 396  * Please use its AUL interface instead of this.
 397  * - None.
 398  *
 399  *
 400  * @param [in] handle
 401  * - handle from tel_init()
 402  *
 403  * @param[in] CallHandle
 404  * - Unique handle for referring the call.
 405  *
 406  * @param [in] callback
 407  *   - To register callback function for result of this function.
 408  *
 409  * @param [in] user_data
 410  *   - user data for user specification
 411  *
 412  * @par Async Response Message:
 413  * - The event associated with this request is TAPI_EVENT_CALL_RETRIEVE_CNF. Asynchronous return status is indicated
 414  *  by #TelCallCause_t and call handle is sent in the event data.
 415  *
 416  * @pre
 417  * - Initialize Dbus connection with #tel_init
 418  * - Register caller's application name with #tel_register_app_name
 419  * - Register telephony events to listen
 420  * - A event loop is running to listen events
 421  * - Call should be in held state in order to retrieve into active state and no active call present.
 422  *
 423  * @post
 424  * - None.
 425  *
 426  * @return Return Type (TapiHandle *handle, int) \n
 427  * - 0 - indicating that the operation has completed successfully. \n
 428  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 429  *
 430  * @par Prospective Clients:
 431  * Embedded call application
 432  *
 433  * @see tel_retrieve_call
 434  *
 435  * @code
 436  * #include <ITapiCall.h>
 437  *
 438  * int ret_status ;
 439  * unsigned int pCallHandle;//held call handle
 440  * int pRequestID=0;
 441  *
 442  * ret_status = tel_retrieve_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // retrieve call
 443  * @endcode
 444  *
 445  * @remarks
 446  * - None
 447  *
 448  *
 449  */
 450 int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
 451
 452  /**
 453  *
 454  * @brief Swap calls. This is only for calls you dialed or answered with Telephony.
 455  * Swap is only available for the voice calls.
 456  *
 457  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 458  * However it just means that the API request has been transfered to the CP successfully.
 459  * The actual operation result is being delivered in the corresponding event asynchronously.
 460  *
 461  * @par Notes:
 462  * During a call, user can place all active calls and accepts the other held call with this function.
 463  * If the terminal is not within a call, it will fail.
 464  *
 465  *
 466  * @par Sync (TapiHandle *handle, or) Async:
 467  * This is an Asynchronous API.
 468  *
 469  * @par Important Notes:
 470  *  - None.
 471  *
 472  * @warning
 473  * Do not use this function. This function is dedicated to the embedded call application only.
 474  * Please use its AUL interface instead of this.
 475  *
 476  *
 477  * @param [in] handle
 478  * - handle from tel_init()
 479  *
 480  * @param[in] CallHandle1
 481  * - This is active call
 482  *
 483  * @param[in] CallHandle2
 484  * - This is Held call
 485  *
 486  * @param [in] callback
 487  *   - To register callback function for result of this function.
 488  *
 489  * @param [in] user_data
 490  *   - user data for user specification
 491  *
 492  * @par Async Response Message:
 493  * -
 494  *
 495  * @pre
 496  * - Initialize Dbus connection with #tel_init
 497  * - Register caller's application name with #tel_register_app_name
 498  * - Register telephony events to listen
 499  * - A event loop is running to listen events
 500  * - None.
 501  *
 502  * @post
 503  * - None.
 504  *
 505  * @return Return Type (TapiHandle *handle, int) \n
 506  * - 0 - indicating that the operation has completed successfully. \n
 507  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 508  *
 509  * @par Prospective Clients:
 510  * Embedded call application
 511  *
 512  * @code
 513  * #include <ITapiCall.h>
 514  *
 515  * int ret_status ;
 516  * unsigned int pCallHandle1;
 517  * unsigned int pCallHandle2;
 518  * int pRequestID=0;
 519  *
 520  * ret_status = tel_swap_call(TapiHandle *handle, pCallHandle1, pCallHandle2,&pRequestID, tapi_response_cb callback, void *user_data); // swap call
 521  * @endcode
 522  *
 523  * @see None.
 524  *
 525  * @remarks
 526  * - None
 527  *
 528  *
 529  */
 530  int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data);
 531
 532  /**
 533  *
 534  * @brief This function sends one or more DTMF digits during the call.
 535  *
 536  * @par Notes:
 537  * DTMF is abbreviation of Dual-tone-multi-frequency. It is used for telecommunication signaling
 538  * over telephone lines in the voice-frequency band between UE and other communications devices.
 539  * For example UE send DTMF tone to a server to choose options which the server provides.
 540  * If the UE is not within a call, this function will fail with error code. *
 541  *
 542  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 543  * However it just means that the API request has been transfered to the CP successfully.
 544  * The actual operation result is being delivered in the corresponding event asynchronously.
 545  *
 546  * @par Sync (TapiHandle *handle, or) Async:
 547  * This is an Asynchronous API.
 548  *
 549  * @par Important Notes:
 550  * -There will be a single asynchronous notification for all the DTMF digits sent. If the users of this API need an asynchronous
 551  *  response for each DTMF digit then User has to call this API multiple times passing each single DTMF digit in pDtmfString.
 552  *
 553  * @warning
 554  * Do not use this function. This function is dedicated to the embedded call application only.
 555  * Please use its AUL interface instead of this.
 556  *
 557  *
 558  * @param [in] handle
 559  * - handle from tel_init()
 560  *
 561  * @param[in] pDtmfString
 562  * - A Null terminated DTMF string to be sent from MS.
 563  *
 564  * @param [in] callback
 565  *   - To register callback function for result of this function.
 566  *
 567  * @param [in] user_data
 568  *   - user data for user specification
 569  *
 570  * @par Async Response Message:
 571  * - The event associated with this request is TAPI_EVENT_CALL_SEND_DTMF_CNF. Asynchronous return status
 572  *  is indicated by #TelCallCause_t and call handle is sent in the event data.
 573  *
 574  * @pre
 575  * - Initialize Dbus connection with #tel_init
 576  * - Register caller's application name with #tel_register_app_name
 577  * - Register telephony events to listen
 578  * - A event loop is running to listen events
 579  * - Active call should be present.
 580  *
 581  * @post
 582  * - None.
 583  *
 584  * @return Return Type (TapiHandle *handle, int) \n
 585  * - 0 - indicating that the operation has completed successfully. \n
 586  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 587  *
 588  * @par Prospective Clients:
 589  * Embedded call application
 590  *
 591  *
 592  * \image html CallDtmf.jpg
 593  * \image latex CallDtmf.jpg
 594  *
 595  * @code
 596  * #include <ITapiCall.h>
 597  *
 598  * int ret_status ;
 599  * unsigned int pCallHandle;
 600  * int pRequestID=0;
 601  * char DtmfString[10] = {0, };
 602  * strcpy(TapiHandle *handle, DtmfString, "123456789", tapi_response_cb callback, void *user_data);//Sample DTMF digits that need to be sent
 603  * ret_status= tel_send_call_dtmf(TapiHandle *handle, DtmfString,&pRequestID, tapi_response_cb callback, void *user_data);
 604  * @endcode
 605  *
 606  *
 607  * @see None.
 608  *
 609  * @remarks
 610  * - None
 611  *
 612  *
 613  */
 614  int tel_call_dtmf(TapiHandle *handle, const char *pDtmfString, tapi_response_cb callback, void *user_data);
 615
 616  /**
 617  *
 618  * @brief This function joins the given two calls (TapiHandle *handle, one call in active conversation state and other call in held state) into conference.
 619  *
 620  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 621  * However it just means that the API request has been transfered to the CP successfully.
 622  * The actual operation result is being delivered in the corresponding event asynchronously.
 623  *
 624  *
 625  * @par Sync (TapiHandle *handle, or) Async:
 626  * This is an Asynchronous API.
 627  *
 628  * @par Important Notes:
 629  * - 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).
 630  *
 631  * @warning
 632  * Do not use this function. This function is dedicated to the embedded call application only.
 633  * Please use its AUL interface instead of this.
 634  *
 635  *
 636  * @param [in] handle
 637  * - handle from tel_init()
 638  *
 639  * @param[in] CallHandle1
 640  * - The unique handle can be either an active call or held call.
 641  *
 642  * @param[in] CallHandle2
 643  * - Unique call handle.
 644  *
 645  * @param [in] callback
 646  *   - To register callback function for result of this function.
 647  *
 648  * @param [in] user_data
 649  *   - user data for user specification
 650  *
 651  * @par Async Response Message:
 652  * - The event associated with this request is TAPI_EVENT_CALL_SETUPCONFERENCE_CNF. Asynchronous return
 653  *  status is indicated by #TelCallCause_t and call handle of the MPTY call is sent in the event data.
 654  *
 655  * @pre
 656  * - Initialize Dbus connection with #tel_init
 657  * - Register caller's application name with #tel_register_app_name
 658  * - Register telephony events to listen
 659  * - A event loop is running to listen events
 660  * - For a Multiparty call or for joining two calls into conference, there should be one call in active state and another call
 661  *  in held state.
 662  *
 663  * @post
 664  * - None.
 665  *
 666  * @return Return Type (TapiHandle *handle, int) \n
 667  * - 0 - indicating that the operation has completed successfully. \n
 668  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 669  *
 670  * @par Prospective Clients:
 671  * Embedded call application
 672  *
 673  * @see tel_split_call
 674  *
 675  * @code
 676  * #include <ITapiCall.h>
 677  *
 678  * int ret_status ;
 679  * unsigned int pCallHandle1;
 680  * unsigned int pCallHandle2;
 681  * int pRequestID=0;
 682  *
 683  * ret_status= tel_join_call(TapiHandle *handle, pCallHandle1, pCallHandle2,&pRequestID, tapi_response_cb callback, void *user_data); // call join
 684  * @endcode
 685  *
 686  * @remarks
 687  * - None
 688  *
 689  *
 690  *
 691  *
 692  */
 693  int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data);
 694
 695  /**
 696  *
 697  * @brief This function triggers to splits a private call from multiparty call. This API allows creating a private communication
 698  *     with one of remote parties in a multiparty session. TAPI client application has to pass the call handle which needs
 699  *     to split from the multiparty call.
 700  *
 701  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 702  * However it just means that the API request has been transfered to the CP successfully.
 703  * The actual operation result is being delivered in the corresponding event asynchronously.
 704  *
 705  *
 706  * @par Sync (TapiHandle *handle, or) Async:
 707  * This is an Asynchronous API.
 708  *
 709  * @par Important Notes:
 710  * - The list of call handles present in the conference call is retrieved using #tel_get_call_conf_list API
 711  *
 712  * @warning
 713  * Do not use this function. This function is dedicated to the embedded call application only.
 714  * Please use its AUL interface instead of this.
 715  *
 716  *
 717  * @param [in] handle
 718  * - handle from tel_init()
 719  *
 720  * @param[in] CallHandle
 721  * - Handle of call to be made private. Call handle referring to the call that is to be split from the conference
 722  *   (TapiHandle *handle, call to be made private).
 723  *
 724  * @param [in] callback
 725  *   - To register callback function for result of this function.
 726  *
 727  * @param [in] user_data
 728  *   - user data for user specification
 729  *
 730  * @par Async Response Message:
 731  * - The event associated with this request is TAPI_EVENT_CALL_SPLITCONFERENCE_CNF. Asynchronous return status
 732  *  is indicated by #TelCallCause_t and call handle for the split call is sent in the event data.
 733  *
 734  * @pre
 735  * - Initialize Dbus connection with #tel_init
 736  * - Register caller's application name with #tel_register_app_name
 737  * - Register telephony events to listen
 738  * - A event loop is running to listen events
 739  * - Call should be in multiparty conference call.
 740  *
 741  * @post
 742  * - Split call will be the active call and the conference will be held call.
 743  *
 744  * @return Return Type (TapiHandle *handle, int) \n
 745  * - 0 - indicating that the operation has completed successfully. \n
 746  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 747  *
 748  * @par Prospective Clients:
 749  * Embedded call application
 750  *
 751  * @see tel_join _call
 752  *
 753  * @code
 754  * #include <ITapiCall.h>
 755  *
 756  * int ret_status ;
 757  * unsigned int pCallHandle;
 758  * int pRequestID=0;
 759  *
 760  * ret_status= tel_split_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call split
 761  * @endcode
 762  *
 763  * @remarks
 764  * - None
 765  *
 766  *
 767  *
 768  *
 769  */
 770  int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
 771
 772  /**
 773  *
 774  * @brief Get the current calling line identification number.
 775  *
 776  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 777  * However it just means that the API request has been transfered to the CP successfully.
 778  * The actual operation result is being delivered in the corresponding event asynchronously.
 779  *
 780  * @par Notes:
 781  * If the USIM card has multiple number, an user can choose which number he use.
 782  * For example, a line is for private, the other line is for business.
 783  * Using this function, user can get information about which line is currently active.
 784  *
 785  * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
 786  * However it just means that the API request has been transfered to the CP successfully.
 787  * The actual operation result is being delivered in the corresponding event asynchronously.
 788  *
 789  * @par Sync (TapiHandle *handle, or) Async:
 790  * This is an Asynchronous API.
 791  *
 792  * @par Important Notes:
 793  * NONE
 794  *
 795  * @warning
 796  * Do not use this function. This function is dedicated to the embedded call application only.
 797  * Please use its AUL interface instead of this.
 798  *
 799  * @param [out] ptr_active_line
 800  *  current active line id.
 801  *
 802  *
 803  * @param [in] handle
 804  * - handle from tel_init()
 805  *
 806  * @param [in] callback
 807  *   - To register callback function for result of this function.
 808  *
 809  * @param [in] user_data
 810  *   - user data for user specification
 811  *
 812  * @pre
 813  * - Initialize Dbus connection with #tel_init
 814  * - Register caller's application name with #tel_register_app_name
 815  * - Register telephony events to listen
 816  * - A event loop is running to listen events
 817  *
 818  * @post
 819  * - None.
 820  *
 821  * @return Return Type (TapiHandle *handle, int) \n
 822  * - 0 - indicating that the operation has completed successfully. \n
 823  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 824  *
 825  * @par Prospective Clients:
 826  * Embedded call application
 827  *
 828  * @see tel_set_call_act_line
 829  *
 830  * @code
 831  * #include <ITapiCall.h>
 832  *
 833  * int pRequestID=0;
 834  * ret_status= tel_get_call_act_line(TapiHandle *handle, &pRequestID, tapi_response_cb callback, void *user_data); // get call active line
 835  * @endcode
 836  *
 837  * @remarks
 838  * - None
 839  *
 840  *
 841  */
 842  int tel_get_call_act_line(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 843
 844  /**
 845  *
 846  * @brief Set the current calling line identification number.
 847  *
 848  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 849  * However it just means that the API request has been transfered to the CP successfully.
 850  * The actual operation result is being delivered in the corresponding event asynchronously.
 851  *
 852  *
 853  * @par Sync (TapiHandle *handle, or) Async:
 854  * This is an Asynchronous API.
 855  *
 856  * @par Important Notes:
 857  * NONE
 858  *
 859  * @warning
 860  * Do not use this function. This function is dedicated to the embedded call application only.
 861  * Please use its AUL interface instead of this.
 862  *
 863  *
 864  * @param [in] handle
 865  * - handle from tel_init()
 866  *
 867  * @param[in] active_line
 868  * - calling line identification
 869  *
 870  * @param [in] callback
 871  *   - To register callback function for result of this function.
 872  *
 873  * @param [in] user_data
 874  *   - user data for user specification
 875  *
 876  * @pre
 877  * - Initialize Dbus connection with #tel_init
 878  * - Register caller's application name with #tel_register_app_name
 879  * - Register telephony events to listen
 880  * - A event loop is running to listen events
 881  *
 882  * @post
 883  * - None.
 884  *
 885  * @return Return Type (TapiHandle *handle, int) \n
 886  * - 0 - indicating that the operation has completed successfully. \n
 887  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 888  *
 889  * @par Prospective Clients:
 890  * Embedded call application
 891  *
 892  * @see tel_get_call_act_line
 893  *
 894  * @code
 895  * #include <ITapiCall.h>
 896  *
 897  * int ret_status ;
 898  * TelCallActiveLine_t g_curLine =TAPI_CALL_ACTIVE_LINE1;
 899  * TelCallActiveLine_t active_line ;
 900  * int pRequestID=0;
 901  *
 902  * ret_status = tel_set_call_act_line (TapiHandle *handle, g_curLine,&pRequestID, tapi_response_cb callback, void *user_data); // set call active line
 903  * @endcode
 904  *
 905  * @remarks
 906  * - None
 907  *
 908  *
 909  */
 910  int tel_set_call_act_line(TapiHandle *handle, TelCallActiveLine_t active_line, tapi_response_cb callback, void *user_data);
 911
 912  /**
 913  *
 914  * @brief This function triggers to do an explicit call transfer by connecting the two parties where in one party being
 915  *     active (TapiHandle *handle, active state) and another party being held (TapiHandle *handle, held state).
 916  *
 917  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
 918  * However it just means that the API request has been transfered to the CP successfully.
 919  * The actual operation result is being delivered in the corresponding event asynchronously.
 920  *
 921  * @par Notes:
 922  * The ECT supplementary service enables the served mobile subscriber (TapiHandle *handle, subscriber A) who has two calls,
 923  * each of which can be an incoming or outgoing call, to connect the other parties in the two calls
 924  * and release the served mobile subscribers own connection.
 925  * Prior to transfer, the connection shall have been established on the call
 926  * between subscriber A and subscriber B. On the call between subscriber A and subscriber C,
 927  * either the connection shall have been established prior to transfer, or, as a network option,
 928  * transfer can occur while subscriber C is being informed of the call
 929  * (TapiHandle *handle, i.e. the connection has not yet been established.)
 930  *
 931  *
 932  * @par Sync (TapiHandle *handle, or) Async:
 933  * This is an Asynchronous API.
 934  *
 935  * @par Important Notes:
 936  * - None.
 937  *
 938  * @warning
 939  * Do not use this function. This function is dedicated to the embedded call application only.
 940  * Please use its AUL interface instead of this.
 941  *
 942  *
 943  * @param [in] handle
 944  * - handle from tel_init()
 945  *
 946  * @param[in] CallHandle
 947  * - Call handle of an active call.
 948  *
 949  * @param [in] callback
 950  *   - To register callback function for result of this function.
 951  *
 952  * @param [in] user_data
 953  *   - user data for user specification
 954  *
 955  * @par Async Response Message:
 956  * - The event associated with this request is TAPI_EVENT_CALL_TRANSFER_CNF. Asynchronous return status is
 957  *  indicated by #TelCallCause_t and call handle is sent in the event data. Call handle in event data is active
 958  *  call handle which is used in the #tel_exe_call_explicit_transfer request.
 959  *
 960  * @pre
 961  * - In order to call transfer, Served mobile subscriber should have 2 calls in one in active state and another one Call
 962  *  in Held state.
 963  *
 964  * @post
 965  * - When the request has been completed successfully, Call end indication will be sent to both the calls (TapiHandle *handle, active and held).
 966  *
 967  * @return Return Type (TapiHandle *handle, int) \n
 968  * - 0 - indicating that the operation has completed successfully. \n
 969  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
 970  *
 971  * @par Prospective Clients:
 972  * Embedded call application
 973  *
 974  * @see None.
 975  *
 976  * @code
 977  * #include <ITapiCall.h>
 978  *
 979  * int ret_status ;
 980  * unsigned int pCallHandle;//active call
 981  * int pRequestID=0;
 982  *
 983  * ret_status= tel_exe_call_explicit_transfer (TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // explicit transfer
 984  * @endcode
 985  *
 986  * @remarks
 987  * -None
 988  *
 989  *
 990  */
 991  int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
 992
 993
 994 /**
 995  *
 996  * @brief This function gets status for the current call identified by Call Handle whenever application wants the call status. Call handle must be valid.
 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 (TapiHandle *handle, or) Async:
1004  * This is a Synchronous 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] handle
1015  * - handle from tel_init()
1016  *
1017  * @param[in] CallHandle
1018  * - Unique handle for referring the call.
1019  *
1020  * @param [out] pCallStatus
1021  *  - Call status information like destination number, call direction (TapiHandle *handle, MO or MT), call type (TapiHandle *handle, voice or data etc), whether
1022  *   the call is in conference state or not, present call state etc are returned through this parameter.
1023  *
1024  * @par Async Response Message:
1025  *  - None.
1026  *
1027  * @pre
1028  * - Initialize Dbus connection with #tel_init
1029  * - Register caller's application name with #tel_register_app_name
1030  * - Register telephony events to listen
1031  * - A event loop is running to listen events
1032  *
1033  * @post
1034  * - None.
1035  *
1036  * @return Return Type (TapiHandle *handle, int) \n
1037  * - 0 - indicating that the operation has completed successfully. \n
1038  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1039  *
1040  * @par Prospective Clients:
1041  * Embedded call application
1042  *
1043  *
1044  *
1045  *
1046  * @code
1047  * #include <ITapiCall.h>
1048  *
1049  * int ret_status ;
1050  * unsigned int CallHandle;
1051  * TelCallStatus_t      callStatus;
1052  *
1053  * ret_status= tel_get_call_status(TapiHandle *handle, CallHandle,&callStatus, tapi_response_cb callback, void *user_data); // get call status info
1054  * @endcode
1055  *
1056  *
1057  * @see None.
1058  *
1059  * @remarks
1060  * - None
1061  *
1062  *
1063  */
1064 int tel_get_call_status(TapiHandle *handle, int call_id, TelCallStatus_t *out );
1065
1066
1067 int tel_get_call_status_all(TapiHandle *handle, TelCallStatusCallback cb, void *user_data) ;
1068
1069
1070  /**
1071  *
1072  * @brief This function gets duration of the given call. This is a synchronous function. Duration is accounted from the moment
1073  *     the connection is established, i.e. call goes into active state for first time.
1074  *
1075  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1076  * However it just means that the API request has been transfered to the CP successfully.
1077  * The actual operation result is being delivered in the corresponding event asynchronously.
1078  *
1079  *
1080  * @par Sync (TapiHandle *handle, or) Async:
1081  * This is a Synchronous API.
1082  *
1083  * @par Important Notes:
1084  *  - None.
1085  *
1086  * @warning
1087  * Do not use this function. This function is dedicated to the embedded call application only.
1088  * Please use its AUL interface instead of this.
1089  *
1090  *
1091  * @param [in] handle
1092  * - handle from tel_init()
1093  *
1094  * @param[in] CallHandle
1095  * - Unique handle for referring the call.
1096  *
1097  * @param [out] pDurationInSecs
1098  *  - The total call duration in seconds from the call connecting time to the present time is returned through this parameter.
1099  *
1100  * @par Async Response Message:
1101  * - None.
1102  *
1103  * @pre
1104  * - Initialize Dbus connection with #tel_init
1105  * - Register caller's application name with #tel_register_app_name
1106  * - Register telephony events to listen
1107  * - A event loop is running to listen events
1108  *
1109  * @post
1110  * - None.
1111  *
1112  * @return Return Type (TapiHandle *handle, int) \n
1113  * - TAPI_API_SUCCESS - indicating that the operation has completed successfully. \n
1114  * - Else it will return failure and error code (TapiHandle *handle, Refer #TapiResult_t)
1115  *
1116  * @par Prospective Clients:
1117  * Embedded call application
1118  *
1119  *
1120  * @code
1121  * #include <ITapiCall.h>
1122  *
1123  * int ret_status ;
1124  * unsigned int CallHandle;
1125  * unsigned int duration;
1126  *
1127  * ret_status= tel_get_call_duration(TapiHandle *handle, CallHandle,&duration, tapi_response_cb callback, void *user_data); // get call duration
1128  * @endcode
1129  *
1130  *
1131  * @see None.
1132  *
1133  * @remarks
1134  * - None
1135  *
1136  *
1137  */
1138  int tel_get_call_duration(TapiHandle *handle, unsigned int CallHandle, unsigned int * pDurationInSecs) ;
1139
1140  /**
1141  *@brief Deflect the incoming call to other subscriber
1142  *
1143  * If informed about an incoming call this call may be redirected to an another destination by
1144  * entering the destination Number. The cleint spcifies the dstiantion number to which the current
1145  * incoming call needs to be redirected is specifed via info argument.
1146  *
1147  *
1148  * @par Sync (TapiHandle *handle, or) Async:
1149  * This is an Asynchronous API.
1150  *
1151  * @par Important Notes:
1152  * - None.
1153  *
1154  * @warning
1155  * Do not use this function. This function is dedicated to the embedded call application only.
1156  * Please use its AUL interface instead of this.
1157  *
1158  *
1159  * @param [in] handle
1160  * - handle from tel_init()
1161  *
1162  * @param[in] CallHandle
1163  * - This is incoming call handle
1164  *
1165  * @param[out] deflect_info
1166  * - Destination Number
1167  *
1168  * @param [in] callback
1169  *   - To register callback function for result of this function.
1170  *
1171  * @param [in] user_data
1172  *   - user data for user specification
1173  *
1174  * @par Async Response Message:
1175  * -
1176  *
1177  * @pre
1178  * - Initialize Dbus connection with #tel_init
1179  * - Register caller's application name with #tel_register_app_name
1180  * - Register telephony events to listen
1181  * - A event loop is running to listen events
1182  *
1183  * @post
1184  * - None.
1185  *
1186  * @return Return Type (TapiHandle *handle, int) \n
1187  * - 0 indicating that the operation has completed successfully. \n
1188  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1189  *
1190  * @par Prospective Clients:
1191  * Embedded call application
1192  *
1193  * @remarks
1194  * - None
1195  *
1196  * @code
1197  * #include <ITapiCall.h>
1198  * #include <TelCall.h>
1199  *
1200  * unsigned int call_handle;
1201  * TelCallDeflectDstInfo_t deflect_info;
1202  * int req_id;
1203  *
1204  * tel_deflect_call(TapiHandle *handle, call_handel, &deflect_info, req_id, tapi_response_cb callback, void *user_data); // call deflect
1205  *
1206  * @endcode
1207  *
1208  * @see None.
1209  *
1210  * @remarks
1211  * - None
1212  *
1213  */
1214  int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *deflect_info, tapi_response_cb callback, void *user_data);
1215
1216
1217  /**
1218  *
1219  * @brief Activate Call Completion to a Busy Subscriber.
1220  *
1221  * @par Notes:
1222  * When subscriber A encounters a Network Determined User Busy (TapiHandle *handle, NDUB) destination B,
1223  * subscriber A can request the CCBS supplementary service (TapiHandle *handle, i.e. activate a CCBS Request against destination B).
1224  * The network will then monitor the wanted destination B for becoming idle.
1225  * When the wanted destination B becomes idle, then the network will wait a short time
1226  * in order to allow destination B to make an outgoing call.
1227  * If destination B does not make any outgoing call within this time,
1228  * then the network shall automatically recall subscriber A.
1229  * When subscriber A accepts the CCBS recall, within a defined time, then the network will automatically
1230  * generate a CCBS call to destination B.
1231  *
1232  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1233  * However it just means that the API request has been transfered to the CP successfully.
1234  * The actual operation result is being delivered in the corresponding event asynchronously.
1235  *
1236  * @par Sync (TapiHandle *handle, or) Async:
1237  * This is an Asynchronous API.
1238  *
1239  * @par Important Notes:
1240  *  - None.
1241  *
1242  * @warning
1243  * Do not use this function. This function is dedicated to the embedded call application only.
1244  * Please use its AUL interface instead of this.
1245  *
1246  *
1247  * @param [in] handle
1248  * - handle from tel_init()
1249  *
1250  * @param [in] CallHandle
1251  * - Handle of the call.
1252  *
1253  * @param [in] callback
1254  *   - To register callback function for result of this function.
1255  *
1256  * @param [in] user_data
1257  *   - user data for user specification
1258  *
1259  * @par Async Response Message:
1260  * -
1261  *
1262  * @pre
1263  * - Initialize Dbus connection with #tel_init
1264  * - Register caller's application name with #tel_register_app_name
1265  * - Register telephony events to listen
1266  * - A event loop is running to listen events
1267  *
1268  * @post
1269  * - None.
1270  *
1271  * @return Return Type (TapiHandle *handle, int) \n
1272  * - 0 - indicating that the operation has completed successfully. \n
1273  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1274  *
1275  * @par Prospective Clients:
1276  * Embedded call application
1277  *
1278  * @code
1279  * #include <ITapiCall.h>
1280  *
1281  * int ret;
1282  * unsigned int call_handle;
1283  * int req_id;
1284  *
1285  * ret = tel_activate_call_ccbs(TapiHandle *handle, call_handle, &req_id, tapi_response_cb callback, void *user_data); // ccbs activate
1286  * @endcode
1287  *
1288  *
1289  * @see None.
1290  *
1291  * @remarks
1292  * - None
1293  *
1294  */
1295  int tel_activate_call_ccbs(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
1296
1297
1298  /**
1299  * @brief This is a synchronous function returns all call handles within the given conference call.
1300  *
1301  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1302  * However it just means that the API request has been transfered to the CP successfully.
1303  * The actual operation result is being delivered in the corresponding event asynchronously.
1304  *
1305  * @par Sync (TapiHandle *handle, or) Async:
1306  * This is a Synchronous API.
1307  *
1308  * @par Important Notes:
1309  * - Call should be a Multi-party conference call in order to return actual no of calls and call handles in the conference calls.
1310  *
1311  * @warning
1312  * Do not use this function. This function is dedicated to the embedded call application only.
1313  * Please use its AUL interface instead of this.
1314  *
1315  *
1316  * @param [in] handle
1317  * - handle from tel_init()
1318  *
1319  * @param[in] CallHandle
1320  * - Handle of call which is associated with the conference.
1321  *
1322  * @param [out] pCallList
1323  *  - list of call joined in the conference call. In case there is no active conference. The list will be zero and
1324  *   number of calls parameter value will also be zero. Maximum number of calls in a conference can be up to 5
1325  *   (TapiHandle *handle, Based on 3GPP TS 22.084). Memory allocation for call list is integer array of size 5.
1326  *
1327  * @param [out] pNoOfCalls
1328  *  - Number of the calls present in conference.
1329  *
1330  * @par Async Response Message:
1331  * -None.
1332  *
1333  * @pre
1334  * - Initialize Dbus connection with #tel_init
1335  * - Register caller's application name with #tel_register_app_name
1336  * - Register telephony events to listen
1337  * - A event loop is running to listen events
1338  *
1339  * @post
1340  * -None.
1341  *
1342  * @return Return Type (TapiHandle *handle, int) \n
1343  * - 0 - indicating that the operation has completed successfully. \n
1344  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1345  *
1346  * @par Prospective Clients:
1347  * Embedded call application
1348  *
1349  * @code
1350  * #include <ITapiCall.h>
1351  *
1352  * int ret_status ;
1353  * unsigned int CallHandle;
1354  * unsigned int callList[5];
1355  * int noOfCalls;
1356  *
1357  * ret_status= tel_get_call_conf_list(TapiHandle *handle, CallHandle, callList, &noOfCalls, tapi_response_cb callback, void *user_data); // get conference call list
1358  * @endcode
1359  *
1360  * @see tel_join_call
1361  *
1362  * @remarks
1363  * - None
1364  *
1365  *
1366  */
1367 int tel_get_call_conf_list(TapiHandle *handle, unsigned int CallHandle, unsigned int *pCallList, int *pNoOfCalls);
1368
1369
1370  /**
1371  *
1372  * @brief This function gets voice privacy option mode in phone(TapiHandle *handle, CDMA only).
1373  *
1374  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1375  * However it just means that the API request has been transfered to the CP successfully.
1376  * The actual operation result is being delivered in the corresponding event asynchronously.
1377  *
1378  * @par Sync (TapiHandle *handle, or) Async:
1379  * This is a Asynchronous API.
1380  *
1381  * @par Important Notes:
1382  *  - None.
1383  *
1384  * @warning
1385  * Do not use this function. This function is dedicated to the embedded call application only.
1386  * Please use its AUL interface instead of this.
1387  *
1388  *
1389  * @param [in] handle
1390  * - handle from tel_init()
1391  *
1392  * @param[in] PrivacyType
1393  * - Privacy Type.
1394  *
1395  * @param [in] callback
1396  *   - To register callback function for result of this function.
1397  *
1398  * @param [in] user_data
1399  *   - user data for user specification
1400  *
1401  * @par Async Response Message:
1402  * - The event associated with this request is TAPI_EVENT_CALL_GET_PRIVACYMODE_CNF. Asynchronous return status
1403  *  is indicated by #TelCallCause_t. #TelCallPrivacyMode_t is included in this event.
1404  *
1405  *
1406  * @pre
1407  * - Initialize Dbus connection with #tel_init
1408  * - Register caller's application name with #tel_register_app_name
1409  * - Register telephony events to listen
1410  * - A event loop is running to listen events
1411  *
1412  * @post
1413  * - None.
1414  *
1415  * @return Return Type (TapiHandle *handle, int) \n
1416  * - 0 - indicating that the operation has completed successfully. \n
1417  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1418  *
1419  * @par Prospective Clients:
1420  * Embedded call application
1421  *
1422  *
1423  *
1424  * @code
1425  * #include <ITapiCall.h>
1426  *
1427  * Int ReqId=-1;
1428  * int ret_status = -1;
1429  * int api_err;
1430  * TelCallPrivacyType_t privacyType;
1431  * privacyType=TAPI_CALL_PRIVACY_TYPE_MS;
1432  * ret_status =tel_get_call_privacy_mode (TapiHandle *handle, privacyType,&req_id, tapi_response_cb callback, void *user_data); // get call privacy_mode
1433  * @endcode
1434  *
1435  *
1436  * @see None.
1437  *
1438  * @remarks
1439  * - None
1440  *
1441  *
1442  */
1443  int tel_get_call_privacy_mode(TapiHandle *handle, TelCallPrivacyType_t PrivacyType, tapi_response_cb callback, void *user_data);
1444
1445
1446  /**
1447  *
1448  * @brief This function sets voice privacy option mode in phone. It is available only where call exists(TapiHandle *handle, CDMA only).
1449  *
1450  *
1451  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1452  * However it just means that the API request has been transfered to the CP successfully.
1453  * The actual operation result is being delivered in the corresponding event asynchronously.
1454  *
1455  * @par Sync (TapiHandle *handle, or) Async:
1456  * This is a Asynchronous API.
1457  *
1458  * @par Important Notes:
1459  *  - None.
1460  *
1461  * @warning
1462  * Do not use this function. This function is dedicated to the embedded call application only.
1463  * Please use its AUL interface instead of this.
1464  *
1465  *
1466  * @param [in] handle
1467  * - handle from tel_init()
1468  *
1469  * @param[in] PrivacyInfo
1470  * - voice privacy option mode(TapiHandle *handle, ENHANCED or STANDARD)
1471  *
1472  * @param [in] callback
1473  *   - To register callback function for result of this function.
1474  *
1475  * @param [in] user_data
1476  *   - user data for user specification
1477  *
1478  * @par Async Response Message:
1479  * - The event associated with this request is TAPI_EVENT_CALL_SET_PRIVACYMODE_CNF. Asynchronous return status
1480  *  is indicated by #TelCallCause_t.
1481  *
1482  *
1483  * @pre
1484  * - Initialize Dbus connection with #tel_init
1485  * - Register caller's application name with #tel_register_app_name
1486  * - Register telephony events to listen
1487  * - A event loop is running to listen events
1488  *
1489  * @post
1490  * - None.
1491  *
1492  * @return Return Type (TapiHandle *handle, int) \n
1493  * - 0 - indicating that the operation has completed successfully. \n
1494  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1495  *
1496  * @par Prospective Clients:
1497  * Embedded call application
1498  *
1499  *
1500  *
1501  * @code
1502  * #include <ITapiCall.h>
1503  *
1504  * int ReqId=-1;
1505  * int ret_status = -1;
1506  * int api_err;
1507  * TelCallPrivacyMode_t pPrivacyMode_info={0,};
1508  * pPrivacyMode_info = TAPI_CALL_PRIVACY_MODE_STANDARD;
1509  *
1510  * ret_status = tel_set_call_privacy_mode (TapiHandle *handle, pPrivacyMode_info,&reqId, tapi_response_cb callback, void *user_data); // set call privacy mode
1511  * @endcode
1512  *
1513  * @see None.
1514  *
1515  * @remarks
1516  * - None
1517  *
1518  *
1519  */
1520  int tel_set_call_privacy_mode(TapiHandle *handle, TelCallVoicePrivacyInfo_t PrivacyInfo, tapi_response_cb callback, void *user_data);
1521
1522
1523 /**
1524  *
1525  * @brief This function requests to send a Flash with Information Message(TapiHandle *handle, CDMA only).
1526  *
1527  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1528  * However it just means that the API request has been transfered to the CP successfully.
1529  * The actual operation result is being delivered in the corresponding event asynchronously.
1530  *
1531  *
1532  * @par Sync (TapiHandle *handle, or) Async:
1533  * This is a Asynchronous API.
1534  *
1535  * @par Important Notes:
1536  *  - None.
1537  *
1538  * @warning
1539  * Do not use this function. This function is dedicated to the embedded call application only.
1540  * Please use its AUL interface instead of this.
1541  *
1542  *
1543  * @param [in] handle
1544  * - handle from tel_init()
1545  *
1546  * @param[in] pDialNumber
1547  * - this is the calling number for 3 way call. But in the call waiting, this param should be NULL.
1548  *
1549  * @param [in] callback
1550  *   - To register callback function for result of this function.
1551  *
1552  * @param [in] user_data
1553  *   - user data for user specification
1554  *
1555  * @par Async Response Message:
1556  * - The event associated with this request is TAPI_EVENT_CALL_FLASHINFO_CNF. Asynchronous return status
1557  *  is indicated by #TelCallCause_t.
1558  *
1559  *
1560  * @pre
1561  * - None.
1562  *
1563  * @post
1564  * - None.
1565  *
1566  * @return Return Type (TapiHandle *handle, int) \n
1567  * - 0 - indicating that the operation has completed successfully. \n
1568  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1569  *
1570  * @par Prospective Clients:
1571  * Embedded call application
1572  *
1573  * @code
1574  * #include <ITapiCall.h>
1575  *
1576  * int ret_status = -1;
1577  * int api_err;
1578  * char const * const pDialNumber = "9999900000";
1579  * ret_status = tel_exe_call_flash_info(TapiHandle *handle, pDialNumber,&reqId, tapi_response_cb callback, void *user_data); // call flash info
1580  * @endcode
1581  *
1582  * @see None.
1583  *
1584  * @remarks
1585  * - None
1586  *
1587  *
1588  */
1589  int tel_exe_call_flash_info(TapiHandle *handle, const char *pDialNumber, tapi_response_cb callback, void *user_data);
1590
1591
1592 /**
1593  *
1594  * @brief This function requests to exit emergency call mode(TapiHandle *handle, CDMA only).
1595  *
1596  * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1597  * However it just means that the API request has been transfered to the CP successfully.
1598  * The actual operation result is being delivered in the corresponding event asynchronously.
1599  *
1600  * @par Sync (TapiHandle *handle, or) Async:
1601  * This is a Asynchronous API.
1602  *
1603  * @par Important Notes:
1604  *  - None.
1605  *
1606  * @warning
1607  * Do not use this function. This function is dedicated to the embedded call application only.
1608  * Please use its AUL interface instead of this.
1609  *
1610  *
1611  * @param [in] handle
1612  * - handle from tel_init()
1613  *
1614  * @param [in] callback
1615  *   - To register callback function for result of this function.
1616  *
1617  * @param [in] user_data
1618  *   - user data for user specification
1619  *
1620  * @par Async Response Message:
1621  * - The event associated with this request is TAPI_EVENT_CALL_EXIT_EMERGENCYMODE_CNF. Asynchronous return status
1622  *  is indicated by #TelCallCause_t.
1623  *
1624  * @pre
1625  * - current state is emergency callback mode.
1626  *
1627  * @post
1628  * - None.
1629  *
1630  * @return Return Type (TapiHandle *handle, int) \n
1631  * - 0 - indicating that the operation has completed successfully. \n
1632  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1633  *
1634  * @par Prospective Clients:
1635  * Embedded call application
1636  *
1637  * @code
1638  * #include <ITapiCall.h>
1639  *
1640  * int req_id;
1641  * int ret;
1642  *
1643  * ret = tel_exit_call_emergency_mode (TapiHandle *handle, &req_id, tapi_response_cb callback, void *user_data); // emergency call
1644  *
1645  * @endcode
1646  *
1647  * @see None.
1648  *
1649  * @remarks
1650  * - None
1651  *
1652  *
1653  */
1654  int tel_exit_call_emergency_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1655
1656
1657 /**
1658  *
1659  * @brief This function is used for querying the information about a call time and call count.
1660  *
1661  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1662  * However it just means that the API request has been transfered to the CP successfully.
1663  * The actual operation result is being delivered in the corresponding event asynchronously.
1664  *
1665  * @par Sync (TapiHandle *handle, or) Async:
1666  * This is a Asynchronous API.
1667  *
1668  * @par Important Notes:
1669  *  - None.
1670  *
1671  * @warning
1672  * Do not use this function. This function is dedicated to the embedded call application only.
1673  * Please use its AUL interface instead of this.
1674  *
1675  *
1676  * @param [in] handle
1677  * - handle from tel_init()
1678  *
1679  * @param[in] req_mask
1680  * - call time request type mask.
1681  *
1682  * @param [in] callback
1683  *   - To register callback function for result of this function.
1684  *
1685  * @param [in] user_data
1686  *   - user data for user specification
1687  *
1688  *
1689  * @par Async Response Message:
1690  * - The event associated with this request is TAPI_EVENT_CALL_GET_CALL_TIME_CNF. Asynchronous return status
1691  *  is indicated by #TelCallCause_t.
1692  *
1693  *
1694  * @pre
1695  * - None.
1696  *
1697  * @post
1698  * - None.
1699  *
1700  * @return Return Type (TapiHandle *handle, int) \n
1701  * - 0 - indicating that the operation has completed successfully. \n
1702  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1703  *
1704  * @par Prospective Clients:
1705  * Embedded call application
1706  *
1707  * @code
1708  * #include <ITapiCall.h>
1709  *
1710  * int ret_status = -1;
1711  * int api_err;
1712  * TelCallTimeMaskType_t mask_byte1 = {0,};
1713  * TelCallTimeMaskType_t mask_byte2 = {0,};
1714  * unsigned short mask_type;
1715  * mask_byte1 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_CNT; //masking call type
1716  * mask_byte2 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_TIME;
1717  *
1718  * mask_type = mask_byte1;
1719  * mask_type << 8;
1720  * mask_type = mask_byte2;
1721  *
1722  * ret_status = tel_get_call_time(TapiHandle *handle, mask_type,&reqId, tapi_response_cb callback, void *user_data);
1723  *
1724  * @endcode
1725  *
1726  * @see None.
1727  *
1728  * @remarks
1729  * - None
1730  *
1731  *
1732  */
1733  int tel_get_call_time(TapiHandle *handle, unsigned short req_mask, tapi_response_cb callback, void *user_data);
1734
1735  /**
1736  *
1737  * @brief This function is to get call volume.
1738  *
1739  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1740  * However it just means that the API request has been transfered to the CP successfully.
1741  * The actual operation result is being delivered in the corresponding event asynchronously.
1742  *
1743  * @par Sync (TapiHandle *handle, or) Async:
1744  * This is a Asynchronous API.
1745  *
1746  * @par Important Notes:
1747  *  - None.
1748  *
1749  * @warning
1750  *
1751  *
1752  *
1753  * @param [in] handle
1754  * - handle from tel_init()
1755  *
1756  * @param [in] device
1757  * - sound device
1758  *
1759  * @param [in] type
1760  * - sound type
1761  *
1762  * @param [in] callback
1763  * - To register callback function for result of this function.
1764  *
1765  * @param [in] user_data
1766  * - user data for user specification
1767  *
1768  * @par Async Response Message:
1769  * - TelCallGetVolumeInfoResp_t
1770  *
1771  * @pre
1772  * - None.
1773  *
1774  * @post
1775  * - None.
1776  *
1777  * @return Return Type (TapiHandle *handle, int) \n
1778  * - 0 - indicating that the operation has completed successfully. \n
1779  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1780  *
1781  * @par Prospective Clients:
1782  * Embedded call application
1783  *
1784  * @see None.
1785  *
1786  * @remarks
1787  * - None
1788  *
1789  *
1790  */
1791
1792  int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data );
1793
1794 /**
1795  *
1796  * @brief This function is to set call volume.
1797  *
1798  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1799  * However it just means that the API request has been transfered to the CP successfully.
1800  * The actual operation result is being delivered in the corresponding event asynchronously.
1801  *
1802  * @par Sync (TapiHandle *handle, or) Async:
1803  * This is a Asynchronous API.
1804  *
1805  * @par Important Notes:
1806  *  - None.
1807  *
1808  * @warning
1809  *
1810  *
1811  *
1812  * @param [in] handle
1813  * - handle from tel_init()
1814  *
1815  * @param [in] path
1816  * - call volume information
1817  *
1818  * @param [in] callback
1819  * - To register callback function for result of this function.
1820  *
1821  * @param [in] user_data
1822  * - user data for user specification
1823  *
1824  * @par Async Response Message:
1825  * - None.
1826  *
1827  * @pre
1828  * - None.
1829  *
1830  * @post
1831  * - None.
1832  *
1833  * @return Return Type (TapiHandle *handle, int) \n
1834  * - 0 - indicating that the operation has completed successfully. \n
1835  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1836  *
1837  * @par Prospective Clients:
1838  * Embedded call application
1839  *
1840  * @see None.
1841  *
1842  * @remarks
1843  * - None
1844  *
1845  *
1846  */
1847
1848 int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data );
1849
1850 /**
1851  *
1852  * @brief This function is to set call sound path.
1853  *
1854  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1855  * However it just means that the API request has been transfered to the CP successfully.
1856  * The actual operation result is being delivered in the corresponding event asynchronously.
1857  *
1858  * @par Sync (TapiHandle *handle, or) Async:
1859  * This is a Asynchronous API.
1860  *
1861  * @par Important Notes:
1862  *  - None.
1863  *
1864  * @warning
1865  *
1866  *
1867  *
1868  * @param [in] handle
1869  * - handle from tel_init()
1870  *
1871  * @param [in] path
1872  * - call sound path information
1873  *
1874  * @param [in] callback
1875  * - To register callback function for result of this function.
1876  *
1877  * @param [in] user_data
1878  * - user data for user specification
1879  *
1880  * @par Async Response Message:
1881  * - None.
1882  *
1883  * @pre
1884  * - None.
1885  *
1886  * @post
1887  * - None.
1888  *
1889  * @return Return Type (TapiHandle *handle, int) \n
1890  * - 0 - indicating that the operation has completed successfully. \n
1891  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1892  *
1893  * @par Prospective Clients:
1894  * Embedded call application
1895  *
1896  * @see None.
1897  *
1898  * @remarks
1899  * - None
1900  *
1901  *
1902  */
1903
1904 int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *path, tapi_response_cb callback, void *user_data );
1905
1906 /**
1907  *
1908  * @brief This function is to set call mute state
1909  *
1910  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1911  * However it just means that the API request has been transfered to the CP successfully.
1912  * The actual operation result is being delivered in the corresponding event asynchronously.
1913  *
1914  * @par Sync (TapiHandle *handle, or) Async:
1915  * This is a Asynchronous API.
1916  *
1917  * @par Important Notes:
1918  *  - None.
1919  *
1920  * @warning
1921  *
1922  *
1923  *
1924  * @param [in] handle
1925  * - handle from tel_init()
1926  *
1927  * @param [in] mute
1928  * - Sound Mute Status
1929  *
1930  * @param [in] callback
1931  * - To register callback function for result of this function.
1932  *
1933  * @param [in] user_data
1934  * - user data for user specification
1935  *
1936  * @par Async Response Message:
1937  * - None.
1938  *
1939  * @pre
1940  * - None.
1941  *
1942  * @post
1943  * - None.
1944  *
1945  * @return Return Type (TapiHandle *handle, int) \n
1946  * - 0 - indicating that the operation has completed successfully. \n
1947  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
1948  *
1949  * @par Prospective Clients:
1950  * Embedded call application
1951  *
1952  * @see None.
1953  *
1954  * @remarks
1955  * - None
1956  *
1957  *
1958  */
1959
1960 int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, tapi_response_cb callback, void *user_data );
1961
1962 /**
1963  *
1964  * @brief This function is to get call mute state
1965  *
1966  * This function makes Dbus method call to Telephony Sever and returns immediate value.
1967  * However it just means that the API request has been transfered to the CP successfully.
1968  * The actual operation result is being delivered in the corresponding event asynchronously.
1969  *
1970  * @par Sync (TapiHandle *handle, or) Async:
1971  * This is a Asynchronous API.
1972  *
1973  * @par Important Notes:
1974  *  - None.
1975  *
1976  * @warning
1977  *
1978  *
1979  *
1980  * @param [in] handle
1981  * - handle from tel_init()
1982  *
1983  * @param [in] callback
1984  * - To register callback function for result of this function.
1985  *
1986  * @param [in] user_data
1987  * - user data for user specification
1988  *
1989  * @par Async Response Message:
1990  * - TelCallGetMuteStatusResp_t
1991  *
1992  * @pre
1993  * - None.
1994  *
1995  * @post
1996  * - None.
1997  *
1998  * @return Return Type (TapiHandle *handle, int) \n
1999  * - 0 - indicating that the operation has completed successfully. \n
2000  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
2001  *
2002  * @par Prospective Clients:
2003  * Embedded call application
2004  *
2005  * @see None.
2006  *
2007  * @remarks
2008  * - None
2009  *
2010  *
2011  */
2012
2013 int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data );
2014
2015 /**
2016  *
2017  * @brief This function is to set call sound recording
2018  *
2019  * This function makes Dbus method call to Telephony Sever and returns immediate value.
2020  * However it just means that the API request has been transfered to the CP successfully.
2021  * The actual operation result is being delivered in the corresponding event asynchronously.
2022  *
2023  * @par Sync (TapiHandle *handle, or) Async:
2024  * This is a Asynchronous API.
2025  *
2026  * @par Important Notes:
2027  *  - None.
2028  *
2029  * @warning
2030  *
2031  *
2032  * @param [in] handle
2033  * - handle from tel_init()
2034  *
2035  * @param [in] on
2036  * - Sound recording on / off
2037  *
2038  * @param [in] callback
2039  * - To register callback function for result of this function.
2040  *
2041  * @param [in] user_data
2042  * - user data for user specification
2043  *
2044  * @par Async Response Message:
2045  * - None.
2046  *
2047  * @pre
2048  * - None.
2049  *
2050  * @post
2051  * - None.
2052  *
2053  * @return Return Type (TapiHandle *handle, int) \n
2054  * - 0 - indicating that the operation has completed successfully. \n
2055  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
2056  *
2057  * @par Prospective Clients:
2058  * Embedded call application
2059  *
2060  * @see None.
2061  *
2062  * @remarks
2063  * - None
2064  *
2065  *
2066  */
2067
2068 int tel_set_call_sound_recording(TapiHandle *handle, TelSoundRecording_t *on, tapi_response_cb callback, void *user_data);
2069
2070 /**
2071  *
2072  * @brief This function is to set call sound equalization.
2073  *
2074  * This function makes Dbus method call to Telephony Sever and returns immediate value.
2075  * However it just means that the API request has been transfered to the CP successfully.
2076  * The actual operation result is being delivered in the corresponding event asynchronously.
2077  *
2078  * @par Sync (TapiHandle *handle, or) Async:
2079  * This is a Asynchronous API.
2080  *
2081  * @par Important Notes:
2082  *  - None.
2083  *
2084  * @warning
2085  *
2086  *
2087  * @param [in] handle
2088  * - handle from tel_init()
2089  *
2090  * @param [in] eq
2091  * - call sound equalization information
2092  *
2093  * @param [in] callback
2094  * - To register callback function for result of this function.
2095  *
2096  * @param [in] user_data
2097  * - user data for user specification
2098  *
2099  * @par Async Response Message:
2100  * - None.
2101  *
2102  * @pre
2103  * - None.
2104  *
2105  * @post
2106  * - None.
2107  *
2108  * @return Return Type (TapiHandle *handle, int) \n
2109  * - 0 - indicating that the operation has completed successfully. \n
2110  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
2111  *
2112  * @par Prospective Clients:
2113  * Embedded call application
2114  *
2115  * @see None.
2116  *
2117  * @remarks
2118  * - None
2119  *
2120  *
2121  */
2122
2123 int tel_set_call_sound_equalization(TapiHandle *handle, TelCallSoundEqualization_t *eq, tapi_response_cb callback, void *user_data);
2124
2125  /**
2126  *
2127  * @brief This function is used for querying the set call sound reduction.
2128  *
2129  * This function makes Dbus method call to Telephony Sever and returns immediate value.
2130  * However it just means that the API request has been transfered to the CP successfully.
2131  * The actual operation result is being delivered in the corresponding event asynchronously.
2132  *
2133  * @par Sync (TapiHandle *handle, or) Async:
2134  * This is a Asynchronous API.
2135  *
2136  * @par Important Notes:
2137  *  - None.
2138  *
2139  * @warning
2140  *
2141  *
2142  *
2143  * @param [in] handle
2144  * - handle from tel_init()
2145  *
2146  * @param [in] noise
2147  * -
2148  *
2149  * @param [in] callback
2150  *   - To register callback function for result of this function.
2151  *
2152  * @param [in] user_data
2153  *   - user data for user specification
2154  *
2155  *
2156  * @par Async Response Message:
2157  * - None.
2158  *
2159  * @pre
2160  * - None.
2161  *
2162  * @post
2163  * - None.
2164  *
2165  * @return Return Type (TapiHandle *handle, int) \n
2166  * - 0 - indicating that the operation has completed successfully. \n
2167  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
2168  *
2169  * @par Prospective Clients:
2170  * Embedded call application
2171  *
2172  * @code
2173  *
2174  * @endcode
2175  *
2176  * @see None.
2177  *
2178  * @remarks
2179  * - None
2180  *
2181  *
2182  */
2183
2184  int tel_set_call_sound_noise_reduction(TapiHandle *handle, TelSoundNoiseReduction_t noise, tapi_response_cb callback, void *user_data);
2185
2186  /**
2187  *
2188  * @brief This function is used to set call sound clock status
2189  *
2190  * This function makes Dbus method call to Telephony Sever and returns immediate value.
2191  * However it just means that the API request has been transfered to the CP successfully.
2192  * The actual operation result is being delivered in the corresponding event asynchronously.
2193  *
2194  * @par Sync (TapiHandle *handle, or) Async:
2195  * This is a Asynchronous API.
2196  *
2197  * @par Important Notes:
2198  *  - None.
2199  *
2200  * @warning
2201  *
2202  *
2203  *
2204  * @param [in] handle
2205  * - handle from tel_init()
2206  *
2207  * @param [in] enable
2208  * - sound clock status ( TRUE : enable, FALSE : disable )
2209  *
2210  * @param [in] callback
2211  *   - To register callback function for result of this function.
2212  *
2213  * @param [in] user_data
2214  *   - user data for user specification
2215  *
2216  *
2217  * @par Async Response Message:
2218  * - None.
2219  *
2220  * @pre
2221  * - None.
2222  *
2223  * @post
2224  * - None.
2225  *
2226  * @return Return Type (TapiHandle *handle, int) \n
2227  * - 0 - indicating that the operation has completed successfully. \n
2228  * - Else it will return failure and error code (TapiHandle *handle, Refer Doxygen doc or #TapiResult_t)
2229  *
2230  * @par Prospective Clients:
2231  * Embedded call application
2232  *
2233  * @code
2234  *
2235  * @endcode
2236  *
2237  * @see None.
2238  *
2239  * @remarks
2240  * - None
2241  *
2242  *
2243  */
2244
2245  int tel_set_call_sound_clock_status(TapiHandle *handle, gboolean status, tapi_response_cb callback, void *user_data );
2246
2247
2248 #ifdef __cplusplus
2249 }
2250 #endif
2251
2252 #endif  /* _ITAPI_CALL_H_ */
2253
2254  /**
2255 * @}
2256 */