4 * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Ja-young Gu <jygu@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
23 * @ingroup TelephonyAPI
24 * @addtogroup TAPI_CALL CALL
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
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
39 #ifndef _ITAPI_CALL_H_
40 #define _ITAPI_CALL_H_
42 #include <tapi_common.h>
44 #include <TelDefines.h>
52 * @brief This function originates MO call setup. This is an asynchronous function. The function completes immediately and
53 * call setup proceeds in background.
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.
59 * @par Sync (TapiHandle *handle, or) Async:
60 * This is an Asynchronous API.
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.
77 * Do not use this function. This function is dedicated to the embedded call application only.
78 * Please use its AUL interface
82 * - handle from tel_init()
85 * - #TelCallSetupParams_t contains the CallType(TapiHandle *handle, whether it is a voice call or data call etc) and number.
87 * @param[out] pCallHandle
88 * - Unique handle for referring the call
90 * @param [in] callback
91 * - To register callback function for result of this function.
93 * @param [in] user_data
94 * - user data for user specification
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]
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
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)
114 * @par Prospective Clients:
115 * Embedded call application
117 * @see tel_exe_call_mo tel_answer_call tel_release_call
118 * \image html CallSetup.jpg
119 * \image latex CallSetup.jpg
122 * #include <ITapiCall.h>
125 * unsigned int pCallHandle;
127 * TelCallSetupParams_t pParams;
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);
134 * ret_status = tel_exe_call_mo (TapiHandle *handle, &pParams,&pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // outgoing call
142 int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data);
145 * @brief This function is used to answer the incoming call by accepting or rejecting the call.
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.
151 * @par Sync (TapiHandle *handle, or) Async:
152 * This is an Asynchronous API.
154 * @par Important Notes:
158 * Do not use this function. This function is dedicated to the embedded call application only.
159 * Please use its AUL interface
163 * - handle from tel_init()
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.
170 * - Answer type - accept / reject / replace / hold and accept. but, for CDMA, only accept is allowed.
172 * @param [in] callback
173 * - To register callback function for result of this function.
175 * @param [in] user_data
176 * - user data for user specification
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.
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.
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)
198 * @par Prospective Clients:
199 * Embedded call application
201 * @see tel_exe_call_mo tel_release_call
203 * \image html CallIncoming.jpg
204 * \image latex CallIncoming.jpg
207 * #include <ITapiCall.h>
210 * unsigned int pCallHandle;
213 * ret_status = tel_answer_call (TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call answer
225 int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data);
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.
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.
237 * @par Sync (TapiHandle *handle, or) Async:
238 * This is an Asynchronous API.
240 * @par Important Notes:
241 * - In case of MPTY Call handle, Call end event is returned for each call in MPTY.
244 * Do not use this function. This function is dedicated to the embedded call application only.
245 * Please use its AUL interface
249 * - handle from tel_init()
251 * @param[in] CallHandle
252 * - Unique handle for referring the call.
254 * @param [in] callback
255 * - To register callback function for result of this function.
257 * @param [in] user_data
258 * - user data for user specification
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..
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.
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.
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)
281 * @par Prospective Clients:
282 * Embedded call application
284 * @see tel_exe_call_mo tel_answer_call tel_release_call_all tel_release_call_all_active
287 * #include <ITapiCall.h>
290 * unsigned int pCallHandle;
293 * ret_status = tel_release_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call release
302 int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data);
307 * @brief This function puts the given call on hold. The call identified by Call Handle should be in active state.
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.
314 * @par Sync (TapiHandle *handle, or) Async:
315 * This is an Asynchronous API.
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.
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.
327 * - handle from tel_init()
329 * @param[in] CallHandle
330 * - Unique handle for referring the call.
332 * @param [in] callback
333 * - To register callback function for result of this function.
335 * @param [in] user_data
336 * - user data for user specification
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.
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.
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)
356 * @par Prospective Clients:
357 * Embedded call application
360 * #include <ITapiCall.h>
363 * unsigned int pCallHandle;//HANDLE OF AN ACTIVE CALL
366 * ret_status = tel_hold_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // hold call
370 * @see tel_retrieve_call
377 int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
381 * @brief This function retrieves the held call. The call identified by Call Handle must be in held state.
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.
388 * @par Sync (TapiHandle *handle, or) Async:
389 * This is an Asynchronous API.
391 * @par Important Notes:
392 * - Call duration for the call will be calculated from the moment call has been connected until call is released.
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.
401 * - handle from tel_init()
403 * @param[in] CallHandle
404 * - Unique handle for referring the call.
406 * @param [in] callback
407 * - To register callback function for result of this function.
409 * @param [in] user_data
410 * - user data for user specification
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.
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.
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)
430 * @par Prospective Clients:
431 * Embedded call application
433 * @see tel_retrieve_call
436 * #include <ITapiCall.h>
439 * unsigned int pCallHandle;//held call handle
442 * ret_status = tel_retrieve_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // retrieve call
450 int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
454 * @brief Swap calls. This is only for calls you dialed or answered with Telephony.
455 * Swap is only available for the voice calls.
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.
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.
466 * @par Sync (TapiHandle *handle, or) Async:
467 * This is an Asynchronous API.
469 * @par Important Notes:
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.
478 * - handle from tel_init()
480 * @param[in] CallHandle1
481 * - This is active call
483 * @param[in] CallHandle2
484 * - This is Held call
486 * @param [in] callback
487 * - To register callback function for result of this function.
489 * @param [in] user_data
490 * - user data for user specification
492 * @par Async Response Message:
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
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)
509 * @par Prospective Clients:
510 * Embedded call application
513 * #include <ITapiCall.h>
516 * unsigned int pCallHandle1;
517 * unsigned int pCallHandle2;
520 * ret_status = tel_swap_call(TapiHandle *handle, pCallHandle1, pCallHandle2,&pRequestID, tapi_response_cb callback, void *user_data); // swap call
530 int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data);
534 * @brief This function sends one or more DTMF digits during the call.
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. *
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.
546 * @par Sync (TapiHandle *handle, or) Async:
547 * This is an Asynchronous API.
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.
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.
559 * - handle from tel_init()
561 * @param[in] pDtmfString
562 * - A Null terminated DTMF string to be sent from MS.
564 * @param [in] callback
565 * - To register callback function for result of this function.
567 * @param [in] user_data
568 * - user data for user specification
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.
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.
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)
588 * @par Prospective Clients:
589 * Embedded call application
592 * \image html CallDtmf.jpg
593 * \image latex CallDtmf.jpg
596 * #include <ITapiCall.h>
599 * unsigned int pCallHandle;
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);
614 int tel_call_dtmf(TapiHandle *handle, const char *pDtmfString, tapi_response_cb callback, void *user_data);
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.
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.
625 * @par Sync (TapiHandle *handle, or) Async:
626 * This is an Asynchronous API.
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).
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.
637 * - handle from tel_init()
639 * @param[in] CallHandle1
640 * - The unique handle can be either an active call or held call.
642 * @param[in] CallHandle2
643 * - Unique call handle.
645 * @param [in] callback
646 * - To register callback function for result of this function.
648 * @param [in] user_data
649 * - user data for user specification
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.
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
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)
670 * @par Prospective Clients:
671 * Embedded call application
673 * @see tel_split_call
676 * #include <ITapiCall.h>
679 * unsigned int pCallHandle1;
680 * unsigned int pCallHandle2;
683 * ret_status= tel_join_call(TapiHandle *handle, pCallHandle1, pCallHandle2,&pRequestID, tapi_response_cb callback, void *user_data); // call join
693 int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data);
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.
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.
706 * @par Sync (TapiHandle *handle, or) Async:
707 * This is an Asynchronous API.
709 * @par Important Notes:
710 * - The list of call handles present in the conference call is retrieved using #tel_get_call_conf_list API
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.
718 * - handle from tel_init()
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).
724 * @param [in] callback
725 * - To register callback function for result of this function.
727 * @param [in] user_data
728 * - user data for user specification
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.
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.
742 * - Split call will be the active call and the conference will be held call.
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)
748 * @par Prospective Clients:
749 * Embedded call application
751 * @see tel_join _call
754 * #include <ITapiCall.h>
757 * unsigned int pCallHandle;
760 * ret_status= tel_split_call(TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // call split
770 int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
774 * @brief Get the current calling line identification number.
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.
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.
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.
789 * @par Sync (TapiHandle *handle, or) Async:
790 * This is an Asynchronous API.
792 * @par Important Notes:
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.
799 * @param [out] ptr_active_line
800 * current active line id.
804 * - handle from tel_init()
806 * @param [in] callback
807 * - To register callback function for result of this function.
809 * @param [in] user_data
810 * - user data for user specification
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
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)
825 * @par Prospective Clients:
826 * Embedded call application
828 * @see tel_set_call_act_line
831 * #include <ITapiCall.h>
834 * ret_status= tel_get_call_act_line(TapiHandle *handle, &pRequestID, tapi_response_cb callback, void *user_data); // get call active line
842 int tel_get_call_act_line(TapiHandle *handle, tapi_response_cb callback, void *user_data);
846 * @brief Set the current calling line identification number.
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.
853 * @par Sync (TapiHandle *handle, or) Async:
854 * This is an Asynchronous API.
856 * @par Important Notes:
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.
865 * - handle from tel_init()
867 * @param[in] active_line
868 * - calling line identification
870 * @param [in] callback
871 * - To register callback function for result of this function.
873 * @param [in] user_data
874 * - user data for user specification
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
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)
889 * @par Prospective Clients:
890 * Embedded call application
892 * @see tel_get_call_act_line
895 * #include <ITapiCall.h>
898 * TelCallActiveLine_t g_curLine =TAPI_CALL_ACTIVE_LINE1;
899 * TelCallActiveLine_t active_line ;
902 * ret_status = tel_set_call_act_line (TapiHandle *handle, g_curLine,&pRequestID, tapi_response_cb callback, void *user_data); // set call active line
910 int tel_set_call_act_line(TapiHandle *handle, TelCallActiveLine_t active_line, tapi_response_cb callback, void *user_data);
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).
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.
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.)
932 * @par Sync (TapiHandle *handle, or) Async:
933 * This is an Asynchronous API.
935 * @par Important Notes:
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.
944 * - handle from tel_init()
946 * @param[in] CallHandle
947 * - Call handle of an active call.
949 * @param [in] callback
950 * - To register callback function for result of this function.
952 * @param [in] user_data
953 * - user data for user specification
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.
961 * - In order to call transfer, Served mobile subscriber should have 2 calls in one in active state and another one Call
965 * - When the request has been completed successfully, Call end indication will be sent to both the calls (TapiHandle *handle, active and held).
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)
971 * @par Prospective Clients:
972 * Embedded call application
977 * #include <ITapiCall.h>
980 * unsigned int pCallHandle;//active call
983 * ret_status= tel_exe_call_explicit_transfer (TapiHandle *handle, pCallHandle,&pRequestID, tapi_response_cb callback, void *user_data); // explicit transfer
991 int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
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.
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.
1003 * @par Sync (TapiHandle *handle, or) Async:
1004 * This is a Synchronous API.
1006 * @par Important Notes:
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.
1014 * @param [in] handle
1015 * - handle from tel_init()
1017 * @param[in] CallHandle
1018 * - Unique handle for referring the call.
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.
1024 * @par Async Response Message:
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
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)
1040 * @par Prospective Clients:
1041 * Embedded call application
1047 * #include <ITapiCall.h>
1050 * unsigned int CallHandle;
1051 * TelCallStatus_t callStatus;
1053 * ret_status= tel_get_call_status(TapiHandle *handle, CallHandle,&callStatus, tapi_response_cb callback, void *user_data); // get call status info
1064 int tel_get_call_status(TapiHandle *handle, int call_id, TelCallStatus_t *out );
1067 int tel_get_call_status_all(TapiHandle *handle, TelCallStatusCallback cb, void *user_data) ;
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.
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.
1080 * @par Sync (TapiHandle *handle, or) Async:
1081 * This is a Synchronous API.
1083 * @par Important Notes:
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.
1091 * @param [in] handle
1092 * - handle from tel_init()
1094 * @param[in] CallHandle
1095 * - Unique handle for referring the call.
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.
1100 * @par Async Response Message:
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
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)
1116 * @par Prospective Clients:
1117 * Embedded call application
1121 * #include <ITapiCall.h>
1124 * unsigned int CallHandle;
1125 * unsigned int duration;
1127 * ret_status= tel_get_call_duration(TapiHandle *handle, CallHandle,&duration, tapi_response_cb callback, void *user_data); // get call duration
1138 int tel_get_call_duration(TapiHandle *handle, unsigned int CallHandle, unsigned int * pDurationInSecs) ;
1141 *@brief Deflect the incoming call to other subscriber
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.
1148 * @par Sync (TapiHandle *handle, or) Async:
1149 * This is an Asynchronous API.
1151 * @par Important Notes:
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.
1159 * @param [in] handle
1160 * - handle from tel_init()
1162 * @param[in] CallHandle
1163 * - This is incoming call handle
1165 * @param[out] deflect_info
1166 * - Destination Number
1168 * @param [in] callback
1169 * - To register callback function for result of this function.
1171 * @param [in] user_data
1172 * - user data for user specification
1174 * @par Async Response Message:
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
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)
1190 * @par Prospective Clients:
1191 * Embedded call application
1197 * #include <ITapiCall.h>
1198 * #include <TelCall.h>
1200 * unsigned int call_handle;
1201 * TelCallDeflectDstInfo_t deflect_info;
1204 * tel_deflect_call(TapiHandle *handle, call_handel, &deflect_info, req_id, tapi_response_cb callback, void *user_data); // call deflect
1214 int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *deflect_info, tapi_response_cb callback, void *user_data);
1219 * @brief Activate Call Completion to a Busy Subscriber.
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.
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.
1236 * @par Sync (TapiHandle *handle, or) Async:
1237 * This is an Asynchronous API.
1239 * @par Important Notes:
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.
1247 * @param [in] handle
1248 * - handle from tel_init()
1250 * @param [in] CallHandle
1251 * - Handle of the call.
1253 * @param [in] callback
1254 * - To register callback function for result of this function.
1256 * @param [in] user_data
1257 * - user data for user specification
1259 * @par Async Response Message:
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
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)
1275 * @par Prospective Clients:
1276 * Embedded call application
1279 * #include <ITapiCall.h>
1282 * unsigned int call_handle;
1285 * ret = tel_activate_call_ccbs(TapiHandle *handle, call_handle, &req_id, tapi_response_cb callback, void *user_data); // ccbs activate
1295 int tel_activate_call_ccbs(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data);
1299 * @brief This is a synchronous function returns all call handles within the given conference call.
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.
1305 * @par Sync (TapiHandle *handle, or) Async:
1306 * This is a Synchronous API.
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.
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.
1316 * @param [in] handle
1317 * - handle from tel_init()
1319 * @param[in] CallHandle
1320 * - Handle of call which is associated with the conference.
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.
1327 * @param [out] pNoOfCalls
1328 * - Number of the calls present in conference.
1330 * @par Async Response Message:
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
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)
1346 * @par Prospective Clients:
1347 * Embedded call application
1350 * #include <ITapiCall.h>
1353 * unsigned int CallHandle;
1354 * unsigned int callList[5];
1357 * ret_status= tel_get_call_conf_list(TapiHandle *handle, CallHandle, callList, &noOfCalls, tapi_response_cb callback, void *user_data); // get conference call list
1360 * @see tel_join_call
1367 int tel_get_call_conf_list(TapiHandle *handle, unsigned int CallHandle, unsigned int *pCallList, int *pNoOfCalls);
1372 * @brief This function gets voice privacy option mode in phone(TapiHandle *handle, CDMA only).
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.
1378 * @par Sync (TapiHandle *handle, or) Async:
1379 * This is a Asynchronous API.
1381 * @par Important Notes:
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.
1389 * @param [in] handle
1390 * - handle from tel_init()
1392 * @param[in] PrivacyType
1395 * @param [in] callback
1396 * - To register callback function for result of this function.
1398 * @param [in] user_data
1399 * - user data for user specification
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.
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
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)
1419 * @par Prospective Clients:
1420 * Embedded call application
1425 * #include <ITapiCall.h>
1428 * int ret_status = -1;
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
1443 int tel_get_call_privacy_mode(TapiHandle *handle, TelCallPrivacyType_t PrivacyType, tapi_response_cb callback, void *user_data);
1448 * @brief This function sets voice privacy option mode in phone. It is available only where call exists(TapiHandle *handle, CDMA only).
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.
1455 * @par Sync (TapiHandle *handle, or) Async:
1456 * This is a Asynchronous API.
1458 * @par Important Notes:
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.
1466 * @param [in] handle
1467 * - handle from tel_init()
1469 * @param[in] PrivacyInfo
1470 * - voice privacy option mode(TapiHandle *handle, ENHANCED or STANDARD)
1472 * @param [in] callback
1473 * - To register callback function for result of this function.
1475 * @param [in] user_data
1476 * - user data for user specification
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.
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
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)
1496 * @par Prospective Clients:
1497 * Embedded call application
1502 * #include <ITapiCall.h>
1505 * int ret_status = -1;
1507 * TelCallPrivacyMode_t pPrivacyMode_info={0,};
1508 * pPrivacyMode_info = TAPI_CALL_PRIVACY_MODE_STANDARD;
1510 * ret_status = tel_set_call_privacy_mode (TapiHandle *handle, pPrivacyMode_info,&reqId, tapi_response_cb callback, void *user_data); // set call privacy mode
1520 int tel_set_call_privacy_mode(TapiHandle *handle, TelCallVoicePrivacyInfo_t PrivacyInfo, tapi_response_cb callback, void *user_data);
1525 * @brief This function requests to send a Flash with Information Message(TapiHandle *handle, CDMA only).
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.
1532 * @par Sync (TapiHandle *handle, or) Async:
1533 * This is a Asynchronous API.
1535 * @par Important Notes:
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.
1543 * @param [in] handle
1544 * - handle from tel_init()
1546 * @param[in] pDialNumber
1547 * - this is the calling number for 3 way call. But in the call waiting, this param should be NULL.
1549 * @param [in] callback
1550 * - To register callback function for result of this function.
1552 * @param [in] user_data
1553 * - user data for user specification
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.
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)
1570 * @par Prospective Clients:
1571 * Embedded call application
1574 * #include <ITapiCall.h>
1576 * int ret_status = -1;
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
1589 int tel_exe_call_flash_info(TapiHandle *handle, const char *pDialNumber, tapi_response_cb callback, void *user_data);
1594 * @brief This function requests to exit emergency call mode(TapiHandle *handle, CDMA only).
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.
1600 * @par Sync (TapiHandle *handle, or) Async:
1601 * This is a Asynchronous API.
1603 * @par Important Notes:
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.
1611 * @param [in] handle
1612 * - handle from tel_init()
1614 * @param [in] callback
1615 * - To register callback function for result of this function.
1617 * @param [in] user_data
1618 * - user data for user specification
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.
1625 * - current state is emergency callback mode.
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)
1634 * @par Prospective Clients:
1635 * Embedded call application
1638 * #include <ITapiCall.h>
1643 * ret = tel_exit_call_emergency_mode (TapiHandle *handle, &req_id, tapi_response_cb callback, void *user_data); // emergency call
1654 int tel_exit_call_emergency_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1659 * @brief This function is used for querying the information about a call time and call count.
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.
1665 * @par Sync (TapiHandle *handle, or) Async:
1666 * This is a Asynchronous API.
1668 * @par Important Notes:
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.
1676 * @param [in] handle
1677 * - handle from tel_init()
1679 * @param[in] req_mask
1680 * - call time request type mask.
1682 * @param [in] callback
1683 * - To register callback function for result of this function.
1685 * @param [in] user_data
1686 * - user data for user specification
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.
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)
1704 * @par Prospective Clients:
1705 * Embedded call application
1708 * #include <ITapiCall.h>
1710 * int ret_status = -1;
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;
1718 * mask_type = mask_byte1;
1720 * mask_type = mask_byte2;
1722 * ret_status = tel_get_call_time(TapiHandle *handle, mask_type,&reqId, tapi_response_cb callback, void *user_data);
1733 int tel_get_call_time(TapiHandle *handle, unsigned short req_mask, tapi_response_cb callback, void *user_data);
1737 * @brief This function is to get call volume.
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.
1743 * @par Sync (TapiHandle *handle, or) Async:
1744 * This is a Asynchronous API.
1746 * @par Important Notes:
1753 * @param [in] handle
1754 * - handle from tel_init()
1756 * @param [in] device
1762 * @param [in] callback
1763 * - To register callback function for result of this function.
1765 * @param [in] user_data
1766 * - user data for user specification
1768 * @par Async Response Message:
1769 * - TelCallGetVolumeInfoResp_t
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)
1781 * @par Prospective Clients:
1782 * Embedded call application
1792 int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data );
1796 * @brief This function is to set call volume.
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.
1802 * @par Sync (TapiHandle *handle, or) Async:
1803 * This is a Asynchronous API.
1805 * @par Important Notes:
1812 * @param [in] handle
1813 * - handle from tel_init()
1816 * - call volume information
1818 * @param [in] callback
1819 * - To register callback function for result of this function.
1821 * @param [in] user_data
1822 * - user data for user specification
1824 * @par Async Response Message:
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)
1837 * @par Prospective Clients:
1838 * Embedded call application
1848 int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data );
1852 * @brief This function is to set call sound path.
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.
1858 * @par Sync (TapiHandle *handle, or) Async:
1859 * This is a Asynchronous API.
1861 * @par Important Notes:
1868 * @param [in] handle
1869 * - handle from tel_init()
1872 * - call sound path information
1874 * @param [in] callback
1875 * - To register callback function for result of this function.
1877 * @param [in] user_data
1878 * - user data for user specification
1880 * @par Async Response Message:
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)
1893 * @par Prospective Clients:
1894 * Embedded call application
1904 int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *path, tapi_response_cb callback, void *user_data );
1908 * @brief This function is to set call mute state
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.
1914 * @par Sync (TapiHandle *handle, or) Async:
1915 * This is a Asynchronous API.
1917 * @par Important Notes:
1924 * @param [in] handle
1925 * - handle from tel_init()
1928 * - Sound Mute Status
1930 * @param [in] callback
1931 * - To register callback function for result of this function.
1933 * @param [in] user_data
1934 * - user data for user specification
1936 * @par Async Response Message:
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)
1949 * @par Prospective Clients:
1950 * Embedded call application
1960 int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, tapi_response_cb callback, void *user_data );
1964 * @brief This function is to get call mute state
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.
1970 * @par Sync (TapiHandle *handle, or) Async:
1971 * This is a Asynchronous API.
1973 * @par Important Notes:
1980 * @param [in] handle
1981 * - handle from tel_init()
1983 * @param [in] callback
1984 * - To register callback function for result of this function.
1986 * @param [in] user_data
1987 * - user data for user specification
1989 * @par Async Response Message:
1990 * - TelCallGetMuteStatusResp_t
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)
2002 * @par Prospective Clients:
2003 * Embedded call application
2013 int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data );
2017 * @brief This function is to set call sound recording
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.
2023 * @par Sync (TapiHandle *handle, or) Async:
2024 * This is a Asynchronous API.
2026 * @par Important Notes:
2032 * @param [in] handle
2033 * - handle from tel_init()
2036 * - Sound recording on / off
2038 * @param [in] callback
2039 * - To register callback function for result of this function.
2041 * @param [in] user_data
2042 * - user data for user specification
2044 * @par Async Response Message:
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)
2057 * @par Prospective Clients:
2058 * Embedded call application
2068 int tel_set_call_sound_recording(TapiHandle *handle, TelSoundRecording_t *on, tapi_response_cb callback, void *user_data);
2072 * @brief This function is to set call sound equalization.
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.
2078 * @par Sync (TapiHandle *handle, or) Async:
2079 * This is a Asynchronous API.
2081 * @par Important Notes:
2087 * @param [in] handle
2088 * - handle from tel_init()
2091 * - call sound equalization information
2093 * @param [in] callback
2094 * - To register callback function for result of this function.
2096 * @param [in] user_data
2097 * - user data for user specification
2099 * @par Async Response Message:
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)
2112 * @par Prospective Clients:
2113 * Embedded call application
2123 int tel_set_call_sound_equalization(TapiHandle *handle, TelCallSoundEqualization_t *eq, tapi_response_cb callback, void *user_data);
2127 * @brief This function is used for querying the set call sound reduction.
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.
2133 * @par Sync (TapiHandle *handle, or) Async:
2134 * This is a Asynchronous API.
2136 * @par Important Notes:
2143 * @param [in] handle
2144 * - handle from tel_init()
2149 * @param [in] callback
2150 * - To register callback function for result of this function.
2152 * @param [in] user_data
2153 * - user data for user specification
2156 * @par Async Response Message:
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)
2169 * @par Prospective Clients:
2170 * Embedded call application
2184 int tel_set_call_sound_noise_reduction(TapiHandle *handle, TelSoundNoiseReduction_t noise, tapi_response_cb callback, void *user_data);
2188 * @brief This function is used to set call sound clock status
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.
2194 * @par Sync (TapiHandle *handle, or) Async:
2195 * This is a Asynchronous API.
2197 * @par Important Notes:
2204 * @param [in] handle
2205 * - handle from tel_init()
2207 * @param [in] enable
2208 * - sound clock status ( TRUE : enable, FALSE : disable )
2210 * @param [in] callback
2211 * - To register callback function for result of this function.
2213 * @param [in] user_data
2214 * - user data for user specification
2217 * @par Async Response Message:
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)
2230 * @par Prospective Clients:
2231 * Embedded call application
2245 int tel_set_call_sound_clock_status(TapiHandle *handle, gboolean status, tapi_response_cb callback, void *user_data );
2252 #endif /* _ITAPI_CALL_H_ */