wearable/include/ITapiCall.h

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