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 (voice / video ) is possible at any given time. @n
39 #ifndef _ITAPI_CALL_H_
40 #define _ITAPI_CALL_H_
43 #include <TelUtility.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 (or) Async:
60 * This is an Asynchronous API.
62 * @par Important Notes:
63 * - If call to tel_exe_call_mo() is successful, call handle and request ID are assigned by Telephony Server
64 * and returned to client by given Call Handle and Request Id parameters. MO call setup continues in
65 * background. There are multiple states involved in the call setup procedure. Upon request completion
66 * successful or not, various event notifications are sent to client along with data associated with event
67 * (Successful data or error information) based on the indication or response received at the Telephony Server.
68 * - Setting up Emergency call
69 * - when #TelCallType_t is voice_call, voice call is setup unless dial_number parameter is an
70 * emergency number known to telephony FW (like 112 for all 2G and above, other numbers may operator
71 * specific or device configuration specific, so Telephony FW will read relevant SIM files and refer to internal
72 * configuration records). If an emergency number is passed and #TelCallType_t is voice_call, Telephony
73 * FW shall setup emergency phone call.
74 * - When #TelCallType_t is emergency call, emergency call is always set up.
77 * Do not use this function. This function is dedicated to the embedded call application only.
78 * Please use its AUL interface
81 * - #TelCallSetupParams_t contains the CallType(whether it is a voice call or data call etc) and number.
83 * @param[out] pCallHandle
84 * - Unique handle for referring the call
86 * @param [out] pRequestId
87 * - Unique identifier for a particular request.
88 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
89 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
91 * @par Async Response Message:
92 * TAPI_EVENT_CALL_SETUP_CNF is sent to the application when the lower layers get the call originate response.
93 * Asynchronous return status is indicated by #TelCallCause_t and call handle is sent in the event data.
94 * Various asynchronous indications are described in the unsolicited notifications section . [Refer, \ref page8]
97 * - Initialize Dbus connection with #tel_init
98 * - Register caller's application name with #tel_register_app_name
99 * - Register telephony events to listen
100 * - A event loop is running to listen events
105 * @return Return Type (int) \n
106 * - 0 - indicating that the operation has completed successfully. \n
107 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
109 * @par Prospective Clients:
110 * Embedded call application
112 * @see tel_exe_call_mo tel_answer_call tel_release_call
113 * \image html CallSetup.jpg
114 * \image latex CallSetup.jpg
117 * #include <ITapiCall.h>
120 * unsigned int pCallHandle;
122 * TelCallSetupParams_t pParams;
124 * char normal[16] = "1234";//Called party number
125 * memset(&pParams, 0, sizeof(TelCallSetupParams_t));
126 * pParams.CallType = TAPI_CALL_TYPE_VOICE;
127 * strcpy(pParams.szNumber,normal);
129 * ret_status = tel_exe_call_mo (&pParams,&pCallHandle,&pRequestID); // outgoing call
137 int tel_exe_call_mo(const TelCallSetupParams_t *pParams, unsigned int *pCallHandle, int * pRequestId);
140 * @brief This function is used to answer the incoming call by accepting or rejecting the call.
142 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
143 * However it just means that the API request has been transfered to the CP successfully.
144 * The actual operation result is being delivered in the corresponding event asynchronously.
146 * @par Sync (or) Async:
147 * This is an Asynchronous API.
149 * @par Important Notes:
153 * Do not use this function. This function is dedicated to the embedded call application only.
154 * Please use its AUL interface
156 * @param[in] CallHandle
157 * - This is the unique handle for referring the call. This call handle is available to Application through incoming call
158 * (TAPI_EVENT_CALL_INCOM_IND) event.
161 * - Answer type - accept / reject / replace / hold and accept. but, for CDMA, only accept is allowed.
163 * @param [out] pRequestId
164 * - Unique identifier for a particular request.
165 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
166 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
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.
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.
184 * @return Return Type (int) \n
185 * - 0 - indicating that the operation has completed successfully. \n
186 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
188 * @par Prospective Clients:
189 * Embedded call application
191 * @see tel_exe_call_mo tel_release_call
193 * \image html CallIncoming.jpg
194 * \image latex CallIncoming.jpg
197 * #include <ITapiCall.h>
200 * unsigned int pCallHandle;
203 * ret_status = tel_answer_call (pCallHandle,&pRequestID); // call answer
215 int tel_answer_call(unsigned int CallHandle, TelCallAnswerType_t AnsType, int * pRequestId);
219 * @brief This function releases the call identified by Call Handle irrespective of call is hold or active state.
220 * It is used when releasing specific active call in multiparty call.
222 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
223 * However it just means that the API request has been transfered to the CP successfully.
224 * The actual operation result is being delivered in the corresponding event asynchronously.
227 * @par Sync (or) Async:
228 * This is an Asynchronous API.
230 * @par Important Notes:
231 * - In case of MPTY Call handle, Call end event is returned for each call in MPTY.
234 * Do not use this function. This function is dedicated to the embedded call application only.
235 * Please use its AUL interface
237 * @param[in] CallHandle
238 * - Unique handle for referring the call.
240 * @param [out] pRequestId
241 * - Unique identifier for a particular request.
242 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
243 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
245 * @par Async Response Message:
246 * - The event associated with this request is TAPI_EVENT_CALL_RELEASE_CNF and Asynchronous return status
247 * is indicated by #TelCallCause_t and call handle for the released call is sent in the event data..
249 * - The event TAPI_EVENT_CALL_END_IND_IND is received as final asynchronous response and the associated data is #TelCallEndInfo_t.
250 * Asynchronous return status is indicated by #TelCallCause_t.
253 * - Initialize Dbus connection with #tel_init
254 * - Register caller's application name with #tel_register_app_name
255 * - Register telephony events to listen
256 * - A event loop is running to listen events
257 * - Call handle should be valid and there should be an existing call in Active/hold state.
262 * @return Return Type (int) \n
263 * - 0 - indicating that the operation has completed successfully. \n
264 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
266 * @par Prospective Clients:
267 * Embedded call application
269 * @see tel_exe_call_mo tel_answer_call tel_release_call_all tel_release_call_all_active
272 * #include <ITapiCall.h>
275 * unsigned int pCallHandle;
278 * ret_status = tel_release_call(pCallHandle,&pRequestID); // call release
287 int tel_release_call(unsigned int CallHandle, int * pRequestId);
291 * @brief This function releases the all the calls irrespective of the call is hold or active state. Due to this API request,
292 * lower layers will release the call and END Indication Event will be sent to all the Applications.
294 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
295 * However it just means that the API request has been transfered to the CP successfully.
296 * The actual operation result is being delivered in the corresponding event asynchronously.
298 * @par Sync (or) Async:
299 * This is an Asynchronous API.
301 * @par Important Notes:
305 * Do not use this function. This function is dedicated to the embedded call application only.
306 * Please use its AUL interface instead of this.
309 * @param [out] pRequestId
310 * - Unique identifier for a particular request.
311 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
312 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
314 * @par Async Response Message:
315 * - This asynchronous event is received for each call getting released.The event associated with this request is
316 * TAPI_EVENT_CALL_END_IND_IND and the associated data is #TelCallEndInfo_t. There will be no request id present associated
317 * with this TAPI_EVENT_CALL_END_IND_IND when this API is called.
318 * Once all the calls are released, Telephony server will indicate application through TAPI Library by sending
319 * TAPI_EVENT_CALL_RELEASE_ALL_CNF. Asynchronous return status is indicated by #TelCallCause_t and there is no
320 * associated event data.
323 * - Initialize Dbus connection with #tel_init
324 * - Register caller's application name with #tel_register_app_name
325 * - Register telephony events to listen
326 * - A event loop is running to listen events
332 * @return Return Type (int) \n
333 * - 0 - indicating that the operation has completed successfully. \n
334 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
336 * @par Prospective Clients:
337 * Embedded call application
340 * #include <ITapiCall.h>
345 * ret_status = tel_release_call_all(&pRequestID); // release call all
355 /*================================================================================================*/
356 int tel_release_call_all (int * pRequestId);
360 * @brief This function releases the all activate call. Due to this API request,
361 * lower layers will release the call and END Indication Event will be sent to all the Applications.
363 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
364 * However it just means that the API request has been transfered to the CP successfully.
365 * The actual operation result is being delivered in the corresponding event asynchronously.
367 * @par Sync (or) Async:
368 * This is an Asynchronous API.
370 * @par Important Notes:
374 * Do not use this function. This function is dedicated to the embedded call application only.
375 * Please use its AUL interface instead of this.
378 * @param [out] pRequestId
379 * - Unique identifier for a particular request.
380 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
381 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
383 * @par Async Response Message:
387 * - Initialize Dbus connection with #tel_init
388 * - Register caller's application name with #tel_register_app_name
389 * - Register telephony events to listen
390 * - A event loop is running to listen events
396 * @return Return Type (int) \n
397 * - 0 - indicating that the operation has completed successfully. \n
398 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
400 * @par Prospective Clients:
401 * Embedded call application
404 * #include <ITapiCall.h>
409 * ret_status = tel_release_call_all_active(&pRequestID); // release all active call
419 int tel_release_call_all_active(int *pRequestId);
423 * @brief This function releases the all held call. Due to this API request,
424 * lower layers will release the call and END Indication Event will be sent to all the Applications.
426 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
427 * However it just means that the API request has been transfered to the CP successfully.
428 * The actual operation result is being delivered in the corresponding event asynchronously.
430 * @par Sync (or) Async:
431 * This is an Asynchronous API.
433 * @par Important Notes:
437 * Do not use this function. This function is dedicated to the embedded call application only.
438 * Please use its AUL interface instead of this.
441 * @param [out] pRequestId
442 * - Unique identifier for a particular request.
443 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
444 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
446 * @par Async Response Message:
450 * - Initialize Dbus connection with #tel_init
451 * - Register caller's application name with #tel_register_app_name
452 * - Register telephony events to listen
453 * - A event loop is running to listen events
459 * @return Return Type (int) \n
460 * - 0 - indicating that the operation has completed successfully. \n
461 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
463 * @par Prospective Clients:
464 * Embedded call application
467 * #include <ITapiCall.h>
472 * ret_status = tel_release_call_all_held(&pRequestID); // release all held call
483 int tel_release_call_all_held(int * pRequestId);
487 * @brief This function puts the given call on hold. The call identified by Call Handle should be in active state.
489 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
490 * However it just means that the API request has been transfered to the CP successfully.
491 * The actual operation result is being delivered in the corresponding event asynchronously.
494 * @par Sync (or) Async:
495 * This is an Asynchronous API.
497 * @par Important Notes:
498 * - Call duration for the call will be calculated from the time call has been connected until call is released,
499 * i.e. Time duration during the call on hold will also be counted.
502 * Do not use this function. This function is dedicated to the embedded call application only.
503 * Please use its AUL interface instead of this.
506 * @param[in] CallHandle
507 * - Unique handle for referring the call.
509 * @param [out] pRequestId
510 * - Unique identifier for a particular request.
511 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
512 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
514 * @par Async Response Message:
515 * - The event associated with this request is TAPI_EVENT_CALL_HOLD_CNF. Asynchronous return status is
516 * indicated by #TelCallCause_t and call handle is sent in the event data.
519 * - Initialize Dbus connection with #tel_init
520 * - Register caller's application name with #tel_register_app_name
521 * - Register telephony events to listen
522 * - A event loop is running to listen events
523 * - The call identified by the Call Handle should be in active state.
528 * @return Return Type (int) \n
529 * - 0 - indicating that the operation has completed successfully. \n
530 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
532 * @par Prospective Clients:
533 * Embedded call application
536 * #include <ITapiCall.h>
539 * unsigned int pCallHandle;//HANDLE OF AN ACTIVE CALL
542 * ret_status = tel_hold_call(pCallHandle,&pRequestID); // hold call
546 * @see tel_retrieve_call
553 int tel_hold_call(unsigned int CallHandle, int * pRequestId);
557 * @brief This function retrieves the held call. The call identified by Call Handle must be in held state.
559 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
560 * However it just means that the API request has been transfered to the CP successfully.
561 * The actual operation result is being delivered in the corresponding event asynchronously.
564 * @par Sync (or) Async:
565 * This is an Asynchronous API.
567 * @par Important Notes:
568 * - Call duration for the call will be calculated from the moment call has been connected until call is released.
571 * Do not use this function. This function is dedicated to the embedded call application only.
572 * Please use its AUL interface instead of this.
576 * @param[in] CallHandle
577 * - Unique handle for referring the call.
579 * @param [out] pRequestId
580 * - Unique identifier for a particular request.
581 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
582 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
584 * @par Async Response Message:
585 * - The event associated with this request is TAPI_EVENT_CALL_RETRIEVE_CNF. Asynchronous return status is indicated
586 * by #TelCallCause_t and call handle is sent in the event data.
589 * - Initialize Dbus connection with #tel_init
590 * - Register caller's application name with #tel_register_app_name
591 * - Register telephony events to listen
592 * - A event loop is running to listen events
593 * - Call should be in held state in order to retrieve into active state and no active call present.
598 * @return Return Type (int) \n
599 * - 0 - indicating that the operation has completed successfully. \n
600 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
602 * @par Prospective Clients:
603 * Embedded call application
605 * @see tel_retrieve_call
608 * #include <ITapiCall.h>
611 * unsigned int pCallHandle;//held call handle
614 * ret_status = tel_retrieve_call(pCallHandle,&pRequestID); // retrieve call
622 int tel_retrieve_call(unsigned int CallHandle, int * pRequestId);
626 * @brief Swap calls. This is only for calls you dialed or answered with Telephony.
627 * Swap is only available for the voice calls.
629 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
630 * However it just means that the API request has been transfered to the CP successfully.
631 * The actual operation result is being delivered in the corresponding event asynchronously.
634 * During a call, user can place all active calls and accepts the other held call with this function.
635 * If the terminal is not within a call, it will fail.
638 * @par Sync (or) Async:
639 * This is an Asynchronous API.
641 * @par Important Notes:
645 * Do not use this function. This function is dedicated to the embedded call application only.
646 * Please use its AUL interface instead of this.
648 * @param[in] CallHandle1
649 * - This is active call
651 * @param[in] CallHandle2
652 * - This is Held call
654 * @param [out] pRequestId
655 * - Unique identifier for a particular request.
656 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
657 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
659 * @par Async Response Message:
663 * - Initialize Dbus connection with #tel_init
664 * - Register caller's application name with #tel_register_app_name
665 * - Register telephony events to listen
666 * - A event loop is running to listen events
672 * @return Return Type (int) \n
673 * - 0 - indicating that the operation has completed successfully. \n
674 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
676 * @par Prospective Clients:
677 * Embedded call application
680 * #include <ITapiCall.h>
683 * unsigned int pCallHandle1;
684 * unsigned int pCallHandle2;
687 * ret_status = tel_swap_call(pCallHandle1, pCallHandle2,&pRequestID); // swap call
697 int tel_swap_call(unsigned int CallHandle1, unsigned int CallHandle2, int * pRequestId);
701 * @brief This function sends one or more DTMF digits during the call.
704 * DTMF is abbreviation of Dual-tone-multi-frequency. It is used for telecommunication signaling
705 * over telephone lines in the voice-frequency band between UE and other communications devices.
706 * For example UE send DTMF tone to a server to choose options which the server provides.
707 * If the UE is not within a call, this function will fail with error code. *
709 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
710 * However it just means that the API request has been transfered to the CP successfully.
711 * The actual operation result is being delivered in the corresponding event asynchronously.
713 * @par Sync (or) Async:
714 * This is an Asynchronous API.
716 * @par Important Notes:
717 * -There will be a single asynchronous notification for all the DTMF digits sent. If the users of this API need an asynchronous
718 * response for each DTMF digit then User has to call this API multiple times passing each single DTMF digit in pDtmfString.
721 * Do not use this function. This function is dedicated to the embedded call application only.
722 * Please use its AUL interface instead of this.
725 * @param[in] pDtmfString
726 * - A Null terminated DTMF string to be sent from MS.
728 * @param [out] pRequestId
729 * - Unique identifier for a particular request.
730 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
731 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
733 * @par Async Response Message:
734 * - The event associated with this request is TAPI_EVENT_CALL_SEND_DTMF_CNF. Asynchronous return status
735 * is indicated by #TelCallCause_t and call handle is sent in the event data.
738 * - Initialize Dbus connection with #tel_init
739 * - Register caller's application name with #tel_register_app_name
740 * - Register telephony events to listen
741 * - A event loop is running to listen events
742 * - Active call should be present.
747 * @return Return Type (int) \n
748 * - 0 - indicating that the operation has completed successfully. \n
749 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
751 * @par Prospective Clients:
752 * Embedded call application
755 * \image html CallDtmf.jpg
756 * \image latex CallDtmf.jpg
759 * #include <ITapiCall.h>
762 * unsigned int pCallHandle;
764 * char DtmfString[10] = {0, };
765 * strcpy(DtmfString, "123456789");//Sample DTMF digits that need to be sent
766 * ret_status= tel_send_call_dtmf(DtmfString,&pRequestID);
777 int tel_send_call_dtmf(const char *pDtmfString, int * pRequestId);
781 * @brief This function joins the given two calls (one call in active conversation state and other call in held state) into conference.
783 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
784 * However it just means that the API request has been transfered to the CP successfully.
785 * The actual operation result is being delivered in the corresponding event asynchronously.
788 * @par Sync (or) Async:
789 * This is an Asynchronous API.
791 * @par Important Notes:
792 * - Call handle of an active call or held call will be made as MPTY-id, and the other call handle will join in a conference).
795 * Do not use this function. This function is dedicated to the embedded call application only.
796 * Please use its AUL interface instead of this.
799 * @param[in] CallHandle1
800 * - The unique handle can be either an active call or held call.
802 * @param[in] CallHandle2
803 * - Unique call handle.
805 * @param [out] pRequestId
806 * - Unique identifier for a particular request.
807 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
808 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
810 * @par Async Response Message:
811 * - The event associated with this request is TAPI_EVENT_CALL_SETUPCONFERENCE_CNF. Asynchronous return
812 * status is indicated by #TelCallCause_t and call handle of the MPTY call is sent in the event data.
815 * - Initialize Dbus connection with #tel_init
816 * - Register caller's application name with #tel_register_app_name
817 * - Register telephony events to listen
818 * - A event loop is running to listen events
819 * - For a Multiparty call or for joining two calls into conference, there should be one call in active state and another call
825 * @return Return Type (int) \n
826 * - 0 - indicating that the operation has completed successfully. \n
827 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
829 * @par Prospective Clients:
830 * Embedded call application
832 * @see tel_split_call
835 * #include <ITapiCall.h>
838 * unsigned int pCallHandle1;
839 * unsigned int pCallHandle2;
842 * ret_status= tel_join_call(pCallHandle1, pCallHandle2,&pRequestID); // call join
852 int tel_join_call(unsigned int CallHandle1, unsigned int CallHandle2, int * pRequestId);
856 * @brief This function triggers to splits a private call from multiparty call. This API allows creating a private communication
857 * with one of remote parties in a multiparty session. TAPI client application has to pass the call handle which needs
858 * to split from the multiparty call.
860 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
861 * However it just means that the API request has been transfered to the CP successfully.
862 * The actual operation result is being delivered in the corresponding event asynchronously.
865 * @par Sync (or) Async:
866 * This is an Asynchronous API.
868 * @par Important Notes:
869 * - The list of call handles present in the conference call is retrieved using #tel_get_call_conf_list API
872 * Do not use this function. This function is dedicated to the embedded call application only.
873 * Please use its AUL interface instead of this.
876 * @param[in] CallHandle
877 * - Handle of call to be made private. Call handle referring to the call that is to be split from the conference
878 * (call to be made private).
880 * @param [out] pRequestId
881 * - Unique identifier for a particular request.
882 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
883 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
885 * @par Async Response Message:
886 * - The event associated with this request is TAPI_EVENT_CALL_SPLITCONFERENCE_CNF. Asynchronous return status
887 * is indicated by #TelCallCause_t and call handle for the split call is sent in the event data.
890 * - Initialize Dbus connection with #tel_init
891 * - Register caller's application name with #tel_register_app_name
892 * - Register telephony events to listen
893 * - A event loop is running to listen events
894 * - Call should be in multiparty conference call.
897 * - Split call will be the active call and the conference will be held call.
899 * @return Return Type (int) \n
900 * - 0 - indicating that the operation has completed successfully. \n
901 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
903 * @par Prospective Clients:
904 * Embedded call application
906 * @see tel_join _call
909 * #include <ITapiCall.h>
912 * unsigned int pCallHandle;
915 * ret_status= tel_split_call(pCallHandle,&pRequestID); // call split
925 int tel_split_call(unsigned int CallHandle, int * pRequestId);
929 * @brief Get the current calling line identification number.
931 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
932 * However it just means that the API request has been transfered to the CP successfully.
933 * The actual operation result is being delivered in the corresponding event asynchronously.
936 * If the USIM card has multiple number, an user can choose which number he use.
937 * For example, a line is for private, the other line is for business.
938 * Using this function, user can get information about which line is currently active.
940 * This API makes Dbus method call to Telephony Sever and gets immediate feedback.
941 * However it just means that the API request has been transfered to the CP successfully.
942 * The actual operation result is being delivered in the corresponding event asynchronously.
944 * @par Sync (or) Async:
945 * This is an Asynchronous API.
947 * @par Important Notes:
951 * Do not use this function. This function is dedicated to the embedded call application only.
952 * Please use its AUL interface instead of this.
954 * @param [out] ptr_active_line
955 * current active line id.
957 * @param [out] pRequestId
958 * - Unique identifier for a particular request.
959 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
960 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
963 * - Initialize Dbus connection with #tel_init
964 * - Register caller's application name with #tel_register_app_name
965 * - Register telephony events to listen
966 * - A event loop is running to listen events
971 * @return Return Type (int) \n
972 * - 0 - indicating that the operation has completed successfully. \n
973 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
975 * @par Prospective Clients:
976 * Embedded call application
978 * @see tel_set_call_act_line
981 * #include <ITapiCall.h>
984 * ret_status= tel_get_call_act_line(&pRequestID); // get call active line
992 int tel_get_call_act_line( int * pRequestId);
996 * @brief Set the current calling line identification number.
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 (or) Async:
1004 * This is an Asynchronous 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] active_line
1015 * - calling line identification
1017 * @param[out] pRequestId
1018 * - Unique identifier for a particular request.
1019 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1020 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1023 * - Initialize Dbus connection with #tel_init
1024 * - Register caller's application name with #tel_register_app_name
1025 * - Register telephony events to listen
1026 * - A event loop is running to listen events
1031 * @return Return Type (int) \n
1032 * - 0 - indicating that the operation has completed successfully. \n
1033 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1035 * @par Prospective Clients:
1036 * Embedded call application
1038 * @see tel_get_call_act_line
1041 * #include <ITapiCall.h>
1044 * TelCallActiveLine_t g_curLine =TAPI_CALL_ACTIVE_LINE1;
1045 * TelCallActiveLine_t active_line ;
1048 * ret_status = tel_set_call_act_line (g_curLine,&pRequestID); // set call active line
1056 int tel_set_call_act_line(TelCallActiveLine_t active_line, int * pRequestId);
1060 * @brief This function triggers to do an explicit call transfer by connecting the two parties where in one party being
1061 * active (active state) and another party being held (held state).
1063 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1064 * However it just means that the API request has been transfered to the CP successfully.
1065 * The actual operation result is being delivered in the corresponding event asynchronously.
1068 * The ECT supplementary service enables the served mobile subscriber (subscriber A) who has two calls ,
1069 * each of which can be an incoming or outgoing call, to connect the other parties in the two calls
1070 * and release the served mobile subscribers own connection.
1071 * Prior to transfer, the connection shall have been established on the call
1072 * between subscriber A and subscriber B. On the call between subscriber A and subscriber C,
1073 * either the connection shall have been established prior to transfer, or, as a network option,
1074 * transfer can occur while subscriber C is being informed of the call
1075 * (i.e. the connection has not yet been established.)
1078 * @par Sync (or) Async:
1079 * This is an Asynchronous API.
1081 * @par Important Notes:
1085 * Do not use this function. This function is dedicated to the embedded call application only.
1086 * Please use its AUL interface instead of this.
1089 * @param[in] CallHandle
1090 * - Call handle of an active call.
1092 * @param [out] pRequestId
1093 * - Unique identifier for a particular request.
1094 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1095 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1097 * @par Async Response Message:
1098 * - The event associated with this request is TAPI_EVENT_CALL_TRANSFER_CNF. Asynchronous return status is
1099 * indicated by #TelCallCause_t and call handle is sent in the event data. Call handle in event data is active
1100 * call handle which is used in the #tel_exe_call_explicit_transfer request.
1103 * - In order to call transfer, Served mobile subscriber should have 2 calls in one in active state and another one Call
1107 * - When the request has been completed successfully, Call end indication will be sent to both the calls (active and held).
1109 * @return Return Type (int) \n
1110 * - 0 - indicating that the operation has completed successfully. \n
1111 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1113 * @par Prospective Clients:
1114 * Embedded call application
1119 * #include <ITapiCall.h>
1122 * unsigned int pCallHandle;//active call
1125 * ret_status= tel_exe_call_explicit_transfer (pCallHandle,&pRequestID); // explicit transfer
1133 int tel_exe_call_explicit_transfer(unsigned int CallHandle, int * pRequestId);
1138 * @brief This function gets status for the current call identified by Call Handle whenever application wants the call status. Call handle must be valid.
1140 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1141 * However it just means that the API request has been transfered to the CP successfully.
1142 * The actual operation result is being delivered in the corresponding event asynchronously.
1145 * @par Sync (or) Async:
1146 * This is a Synchronous API.
1148 * @par Important Notes:
1152 * Do not use this function. This function is dedicated to the embedded call application only.
1153 * Please use its AUL interface instead of this.
1156 * @param[in] CallHandle
1157 * - Unique handle for referring the call.
1159 * @param [out] pCallStatus
1160 * - Call status information like destination number, call direction (MO or MT), call type (voice or data etc), whether
1161 * the call is in conference state or not, present call state etc are returned through this parameter.
1163 * @par Async Response Message:
1167 * - Initialize Dbus connection with #tel_init
1168 * - Register caller's application name with #tel_register_app_name
1169 * - Register telephony events to listen
1170 * - A event loop is running to listen events
1175 * @return Return Type (int) \n
1176 * - 0 - indicating that the operation has completed successfully. \n
1177 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1179 * @par Prospective Clients:
1180 * Embedded call application
1186 * #include <ITapiCall.h>
1189 * unsigned int CallHandle;
1190 * TelCallStatus_t callStatus;
1192 * ret_status= tel_get_call_status(CallHandle,&callStatus); // get call status info
1204 int tel_get_call_status(unsigned int CallHandle, TelCallStatus_t * pCallStatus) ;
1209 * @brief This function gets duration of the given call. This is a synchronous function. Duration is accounted from the moment
1210 * the connection is established, i.e. call goes into active state for first time.
1212 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1213 * However it just means that the API request has been transfered to the CP successfully.
1214 * The actual operation result is being delivered in the corresponding event asynchronously.
1217 * @par Sync (or) Async:
1218 * This is a Synchronous API.
1220 * @par Important Notes:
1224 * Do not use this function. This function is dedicated to the embedded call application only.
1225 * Please use its AUL interface instead of this.
1228 * @param[in] CallHandle
1229 * - Unique handle for referring the call.
1231 * @param [out] pDurationInSecs
1232 * - The total call duration in seconds from the call connecting time to the present time is returned through this parameter.
1234 * @par Async Response Message:
1238 * - Initialize Dbus connection with #tel_init
1239 * - Register caller's application name with #tel_register_app_name
1240 * - Register telephony events to listen
1241 * - A event loop is running to listen events
1246 * @return Return Type (int) \n
1247 * - TAPI_API_SUCCESS - indicating that the operation has completed successfully. \n
1248 * - Else it will return failure and error code (Refer #TapiResult_t)
1250 * @par Prospective Clients:
1251 * Embedded call application
1257 * #include <ITapiCall.h>
1260 * unsigned int CallHandle;
1261 * unsigned int duration;
1263 * ret_status= tel_get_call_duration(CallHandle,&duration); // get call duration
1274 int tel_get_call_duration(unsigned int CallHandle, unsigned int * pDurationInSecs) ;
1277 *@brief Deflect the incoming call to other subscriber
1279 * If informed about an incoming call this call may be redirected to an another destination by
1280 * entering the destination Number. The cleint spcifies the dstiantion number to which the current
1281 * incoming call needs to be redirected is specifed via info argument.
1284 * @par Sync (or) Async:
1285 * This is an Asynchronous API.
1287 * @par Important Notes:
1291 * Do not use this function. This function is dedicated to the embedded call application only.
1292 * Please use its AUL interface instead of this.
1294 * @param[in] CallHandle
1295 * - This is incoming call handle
1297 * @param[out] deflect_info
1298 * - Destination Number
1300 * @param [out] pRequestID
1301 * - Unique identifier for a particular request.
1302 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1303 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1305 * @par Async Response Message:
1309 * - Initialize Dbus connection with #tel_init
1310 * - Register caller's application name with #tel_register_app_name
1311 * - Register telephony events to listen
1312 * - A event loop is running to listen events
1317 * @return Return Type (int) \n
1318 * - 0 indicating that the operation has completed successfully. \n
1319 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1321 * @par Prospective Clients:
1322 * Embedded call application
1328 * #include <ITapiCall.h>
1329 * #include <TelCall.h>
1331 * unsigned int call_handle;
1332 * TelCallDeflectDstInfo_t deflect_info;
1335 * tel_deflect_call( call_handel, &deflect_info, req_id); // call deflect
1345 int tel_deflect_call(unsigned int CallHandle, const TelCallDeflectDstInfo_t *deflect_info, int *pRequestID);
1350 * @brief Activate Call Completion to a Busy Subscriber.
1353 * When subscriber A encounters a Network Determined User Busy (NDUB) destination B,
1354 * subscriber A can request the CCBS supplementary service (i.e. activate a CCBS Request against destination B).
1355 * The network will then monitor the wanted destination B for becoming idle.
1356 * When the wanted destination B becomes idle, then the network will wait a short time
1357 * in order to allow destination B to make an outgoing call.
1358 * If destination B does not make any outgoing call within this time,
1359 * then the network shall automatically recall subscriber A.
1360 * When subscriber A accepts the CCBS recall, within a defined time, then the network will automatically
1361 * generate a CCBS call to destination B.
1363 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1364 * However it just means that the API request has been transfered to the CP successfully.
1365 * The actual operation result is being delivered in the corresponding event asynchronously.
1367 * @par Sync (or) Async:
1368 * This is an Asynchronous API.
1370 * @par Important Notes:
1374 * Do not use this function. This function is dedicated to the embedded call application only.
1375 * Please use its AUL interface instead of this.
1377 * @param [in] CallHandle
1378 * - Handle of the call.
1380 * @param [out] pRequestID
1381 * - Unique identifier for a particular request.
1382 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1383 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1385 * @par Async Response Message:
1389 * - Initialize Dbus connection with #tel_init
1390 * - Register caller's application name with #tel_register_app_name
1391 * - Register telephony events to listen
1392 * - A event loop is running to listen events
1397 * @return Return Type (int) \n
1398 * - 0 - indicating that the operation has completed successfully. \n
1399 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1401 * @par Prospective Clients:
1402 * Embedded call application
1405 * #include <ITapiCall.h>
1408 * unsigned int call_handle;
1411 * ret = tel_activate_call_ccbs( call_handle, &req_id ); // ccbs activate
1421 int tel_activate_call_ccbs(unsigned int CallHandle, int * pRequestID);
1425 * @brief This is a synchronous function returns all call handles within the given conference call.
1427 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1428 * However it just means that the API request has been transfered to the CP successfully.
1429 * The actual operation result is being delivered in the corresponding event asynchronously.
1431 * @par Sync (or) Async:
1432 * This is a Synchronous API.
1434 * @par Important Notes:
1435 * - Call should be a Multi-party conference call in order to return actual no of calls and call handles in the conference calls.
1438 * Do not use this function. This function is dedicated to the embedded call application only.
1439 * Please use its AUL interface instead of this.
1442 * @param[in] CallHandle
1443 * - Handle of call which is associated with the conference.
1445 * @param [out] pCallList
1446 * - list of call joined in the conference call. In case there is no active conference. The list will be zero and
1447 * number of calls parameter value will also be zero. Maximum number of calls in a conference can be up to 5
1448 * (Based on 3GPP TS 22.084). Memory allocation for call list is integer array of size 5.
1450 * @param [out] pNoOfCalls
1451 * - Number of the calls present in conference.
1453 * @par Async Response Message:
1457 * - Initialize Dbus connection with #tel_init
1458 * - Register caller's application name with #tel_register_app_name
1459 * - Register telephony events to listen
1460 * - A event loop is running to listen events
1465 * @return Return Type (int) \n
1466 * - 0 - indicating that the operation has completed successfully. \n
1467 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1469 * @par Prospective Clients:
1470 * Embedded call application
1473 * #include <ITapiCall.h>
1476 * unsigned int CallHandle;
1477 * unsigned int callList[5];
1480 * ret_status= tel_get_call_conf_list(CallHandle, callList, &noOfCalls); // get conference call list
1483 * @see tel_join_call
1490 int tel_get_call_conf_list (unsigned int CallHandle, const unsigned int * pCallList, int * pNoOfCalls);
1495 * @brief This function gets voice privacy option mode in phone(CDMA only).
1497 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1498 * However it just means that the API request has been transfered to the CP successfully.
1499 * The actual operation result is being delivered in the corresponding event asynchronously.
1501 * @par Sync (or) Async:
1502 * This is a Asynchronous API.
1504 * @par Important Notes:
1508 * Do not use this function. This function is dedicated to the embedded call application only.
1509 * Please use its AUL interface instead of this.
1512 * @param[in] PrivacyType
1515 * @param [out] pRequestID
1516 * - Unique identifier for a particular request.
1517 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1518 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1521 * @par Async Response Message:
1522 * - The event associated with this request is TAPI_EVENT_CALL_GET_PRIVACYMODE_CNF. Asynchronous return status
1523 * is indicated by #TelCallCause_t. #TelCallPrivacyMode_t is included in this event.
1527 * - Initialize Dbus connection with #tel_init
1528 * - Register caller's application name with #tel_register_app_name
1529 * - Register telephony events to listen
1530 * - A event loop is running to listen events
1535 * @return Return Type (int) \n
1536 * - 0 - indicating that the operation has completed successfully. \n
1537 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1539 * @par Prospective Clients:
1540 * Embedded call application
1545 * #include <ITapiCall.h>
1548 * int ret_status = -1;
1550 * TelCallPrivacyType_t privacyType;
1551 * privacyType=TAPI_CALL_PRIVACY_TYPE_MS;
1552 * ret_status =tel_get_call_privacy_mode (privacyType,&req_id); // get call privacy_mode
1563 int tel_get_call_privacy_mode(TelCallPrivacyType_t PrivacyType, int * pRequestID);
1568 * @brief This function sets voice privacy option mode in phone. It is available only where call exists(CDMA only).
1571 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1572 * However it just means that the API request has been transfered to the CP successfully.
1573 * The actual operation result is being delivered in the corresponding event asynchronously.
1575 * @par Sync (or) Async:
1576 * This is a Asynchronous API.
1578 * @par Important Notes:
1582 * Do not use this function. This function is dedicated to the embedded call application only.
1583 * Please use its AUL interface instead of this.
1586 * @param[in] PrivacyInfo
1587 * - voice privacy option mode(ENHANCED or STANDARD)
1590 * @param [out] pRequestID
1591 * - Unique identifier for a particular request.
1592 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1593 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1596 * @par Async Response Message:
1597 * - The event associated with this request is TAPI_EVENT_CALL_SET_PRIVACYMODE_CNF. Asynchronous return status
1598 * is indicated by #TelCallCause_t.
1602 * - Initialize Dbus connection with #tel_init
1603 * - Register caller's application name with #tel_register_app_name
1604 * - Register telephony events to listen
1605 * - A event loop is running to listen events
1610 * @return Return Type (int) \n
1611 * - 0 - indicating that the operation has completed successfully. \n
1612 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1614 * @par Prospective Clients:
1615 * Embedded call application
1620 * #include <ITapiCall.h>
1623 * int ret_status = -1;
1625 * TelCallPrivacyMode_t pPrivacyMode_info={0,};
1626 * pPrivacyMode_info = TAPI_CALL_PRIVACY_MODE_STANDARD;
1628 * ret_status = tel_set_call_privacy_mode (pPrivacyMode_info,&reqId); // set call privacy mode
1638 int tel_set_call_privacy_mode(TelCallVoicePrivacyInfo_t PrivacyInfo, int * pRequestID);
1643 * @brief This function requests to send a Flash with Information Message(CDMA only).
1645 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1646 * However it just means that the API request has been transfered to the CP successfully.
1647 * The actual operation result is being delivered in the corresponding event asynchronously.
1650 * @par Sync (or) Async:
1651 * This is a Asynchronous API.
1653 * @par Important Notes:
1657 * Do not use this function. This function is dedicated to the embedded call application only.
1658 * Please use its AUL interface instead of this.
1661 * @param[in] pDialNumber
1662 * - this is the calling number for 3 way call. But in the call waiting, this param should be NULL.
1665 * @param [out] pRequestID
1666 * - Unique identifier for a particular request.
1667 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1668 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1671 * @par Async Response Message:
1672 * - The event associated with this request is TAPI_EVENT_CALL_FLASHINFO_CNF. Asynchronous return status
1673 * is indicated by #TelCallCause_t.
1682 * @return Return Type (int) \n
1683 * - 0 - indicating that the operation has completed successfully. \n
1684 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1686 * @par Prospective Clients:
1687 * Embedded call application
1690 * #include <ITapiCall.h>
1692 * int ret_status = -1;
1694 * char const * const pDialNumber = "9999900000";
1695 * ret_status = tel_exe_call_flash_info(pDialNumber,&reqId); // call flash info
1705 int tel_exe_call_flash_info(const char *pDialNumber, int * pRequestID);
1710 * @brief This function requests to exit emergency call mode(CDMA only).
1712 * This function makes Dbus method call to Telephony Sever and gets immediate feedback.
1713 * However it just means that the API request has been transfered to the CP successfully.
1714 * The actual operation result is being delivered in the corresponding event asynchronously.
1716 * @par Sync (or) Async:
1717 * This is a Asynchronous API.
1719 * @par Important Notes:
1723 * Do not use this function. This function is dedicated to the embedded call application only.
1724 * Please use its AUL interface instead of this.
1726 * @param[out] pRequestID
1727 * - Unique identifier for a particular request.
1728 * Request Id value can be any value from 0 to 255 if the API is returned successfully
1729 * -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1731 * @par Async Response Message:
1732 * - The event associated with this request is TAPI_EVENT_CALL_EXIT_EMERGENCYMODE_CNF. Asynchronous return status
1733 * is indicated by #TelCallCause_t.
1736 * - current state is emergency callback mode.
1741 * @return Return Type (int) \n
1742 * - 0 - indicating that the operation has completed successfully. \n
1743 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1745 * @par Prospective Clients:
1746 * Embedded call application
1749 * #include <ITapiCall.h>
1754 * ret = tel_exit_call_emergency_mode ( &req_id ); // emergency call
1765 int tel_exit_call_emergency_mode(int * pRequestID);
1770 * @brief This function is used for querying the information about a call time and call count.
1772 * This function makes Dbus method call to Telephony Sever and returns immediate value.
1773 * However it just means that the API request has been transfered to the CP successfully.
1774 * The actual operation result is being delivered in the corresponding event asynchronously.
1776 * @par Sync (or) Async:
1777 * This is a Asynchronous API.
1779 * @par Important Notes:
1783 * Do not use this function. This function is dedicated to the embedded call application only.
1784 * Please use its AUL interface instead of this.
1787 * @param[in] req_mask
1788 * - call time request type mask.
1790 * @param[out] pRequestID
1791 * - Unique identifier for a particular request.
1792 * - Request Id value can be any value from 0 to 255 if the API is returned successfully
1793 * - -1 (INVALID_REQUEST_ID) will be sent in case of failure.
1796 * @par Async Response Message:
1797 * - The event associated with this request is TAPI_EVENT_CALL_GET_CALL_TIME_CNF. Asynchronous return status
1798 * is indicated by #TelCallCause_t.
1807 * @return Return Type (int) \n
1808 * - 0 - indicating that the operation has completed successfully. \n
1809 * - Else it will return failure and error code (Refer Doxygen doc or #TapiResult_t)
1811 * @par Prospective Clients:
1812 * Embedded call application
1815 * #include <ITapiCall.h>
1817 * int ret_status = -1;
1819 * TelCallTimeMaskType_t mask_byte1 = {0,};
1820 * TelCallTimeMaskType_t mask_byte2 = {0,};
1821 * unsigned short mask_type;
1822 * mask_byte1 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_CNT; //masking call type
1823 * mask_byte2 = TAPI_CALL_TIME_TYPE_TOTAL_CALL_TIME;
1825 * mask_type = mask_byte1;
1827 * mask_type = mask_byte2;
1829 * ret_status = tel_get_call_time(mask_type,&reqId);
1840 int tel_get_call_time(unsigned short req_mask, int * pRequestID);
1847 #endif /* _ITAPI_CALL_H_ */