call-engine/core/vc-core-tapi-rqst.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <sys/time.h>
  19 #include "vc-core-tapi-rqst.h"
  20 #include "vc-core-util.h"
  21 #include "vc-core-engine-types.h"
  22
  23 static int gcall_vc_callmember_count = 0;
  24 static gboolean gcall_vc_callend_wait = FALSE;
  25
  26 #ifdef _CALL_LONG_DTMF
  27 static char gsz_dtmf_buffer[TAPI_CALL_DIALDIGIT_LEN_MAX + 1];
  28 static int gdtmf_headindex = 0;
  29 static int gdtmf_tailindex = 0;
  30 static call_vc_dtmf_bufferstate_t gdtmf_buffer_state = CALL_VC_DTMF_BUF_NONE;
  31 static gboolean glong_dtmf_mode = FALSE;
  32 #endif
  33
  34 /*Local Function Declerations */
  35 /**
  36 * This function splits the given call from the conference call , if available
  37 *
  38 * @internal
  39 * @return               Returns TRUE on success or FALSE on failure
  40 * @param[in]            call_handle             handle of the call to be splitted
  41 */
  42 static gboolean __call_vc_split_member(call_vc_handle call_handle);
  43
  44  /**
  45  * This function prepares for a call setup
  46  *
  47  * @return              Returns TRUE on success and FALSE on failure
  48  * @param[in]           pcall_agent                     Pointer to the call agent state
  49  */
  50 gboolean _vc_core_tapi_rqst_prepare_setup_call(call_vc_callagent_state_t *pcall_agent)
  51 {
  52         call_vc_call_objectinfo_t callobject_info = { 0 };
  53
  54         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
  55
  56         CALL_ENG_DEBUG(ENG_DEBUG, "IO State =%d, Agent State: %d", pcall_agent->io_state, pcall_agent->callagent_state);
  57
  58         _vc_core_cm_clear_call_object(&callobject_info);
  59         if ((_vc_core_cm_get_outgoing_call_info(&pcall_agent->call_manager, &callobject_info) == FALSE) || (strlen(callobject_info.tel_number) == 0) || (pcall_agent->callagent_state != CALL_VC_CA_STATE_NORMAL)) {
  60                 CALL_ENG_DEBUG(ENG_DEBUG, "MO Call Not Possible: Number: %s", callobject_info.tel_number);
  61                 return FALSE;
  62         } else if (_vc_core_cm_isexists_active_call(&pcall_agent->call_manager) && _vc_core_cm_isexists_held_call(&pcall_agent->call_manager)) {
  63                 /*Emergency calls should be established, even when active or hold calls exists */
  64                 if (TRUE == callobject_info.bemergency_number) {
  65                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_RELEASE_ALL_CALLS_TO_SETUP);
  66                         _vc_core_tapi_rqst_release_all_calls(pcall_agent);
  67                         return TRUE;
  68                 } else {
  69                         CALL_ENG_DEBUG(ENG_DEBUG, "Active&Held call exist!");
  70                         return FALSE;
  71                 }
  72         } else if (_vc_core_cm_isexists_active_call(&pcall_agent->call_manager)) {
  73                 CALL_ENG_DEBUG(ENG_DEBUG, "There is active call when trying new call...");
  74
  75                 /* Change the In Out State accordingly after Hold Call */
  76                 if (_vc_core_tapi_rqst_hold_call(pcall_agent) == FALSE) {
  77                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
  78                         return FALSE;
  79                 } else {
  80                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_HOLD);
  81                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_HOLD);
  82                         return TRUE;
  83                 }
  84         } else {
  85                 if (_vc_core_tapi_rqst_setup_call(pcall_agent) == FALSE) {
  86                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
  87                         CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_tapi_rqst_prepare_setup_call:Fail to _vc_core_tapi_rqst_setup_call");
  88                         return FALSE;
  89                 } else {
  90                         /* Wait for the TAPI_EVENT_CALL_ORIG */
  91                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_ORIG);
  92                         return TRUE;
  93                 }
  94         }
  95
  96         return FALSE;
  97 }
  98
  99  /**
 100  * This function sets up an outgoing call
 101  *
 102  * @return              Returns TRUE on success and FALSE on failure
 103  * @param[in]           pcall_agent                     Pointer to the call agent state
 104  */
 105 gboolean _vc_core_tapi_rqst_setup_call(call_vc_callagent_state_t *pcall_agent)
 106 {
 107         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 108         TelCallSetupParams_t setupCallInfo;
 109 /*      TelCallCugInfo_t pCugInfo = {0,};*/
 110         call_vc_call_objectinfo_t callobject_info = { 0 };
 111 /*      TelCallIdentityMode_t   identityMode = TAPI_CALL_IDENTITY_DEFAULT;*/
 112         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 113         int ReqId = VC_RQSTID_DEFAULT;
 114         clock_t start;
 115         clock_t end;
 116
 117         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 118
 119         memset(&setupCallInfo, 0, sizeof(TelCallSetupParams_t));
 120
 121         /* Get the Outgoing Call Info */
 122         _vc_core_cm_clear_call_object(&callobject_info);
 123         if (_vc_core_cm_get_outgoing_call_info(&pcall_agent->call_manager, &callobject_info) == FALSE) {
 124                 CALL_ENG_DEBUG(ENG_DEBUG, "Outgoing call info does not exist!");
 125                 return FALSE;
 126         }
 127         /* set setupCallInfo structure for call setup */
 128         if (callobject_info.bemergency_number == TRUE) {
 129                 CALL_ENG_DEBUG(ENG_DEBUG, "Emergency call!");
 130                 setupCallInfo.CallType = TAPI_CALL_TYPE_E911;
 131                 /*setupCallInfo.Ecc = callobject_info.ecc_category;
 132                 CALL_ENG_DEBUG(ENG_DEBUG,"Emergency call, ecc_category:[%d]!", callobject_info.ecc_category);*/
 133         } else {
 134                 CALL_ENG_DEBUG(ENG_DEBUG, "Normal call!");
 135                 setupCallInfo.CallType = TAPI_CALL_TYPE_VOICE;
 136         }
 137
 138         /*Set the Call Object MO Flag as TRUE */
 139         callobject_info.mo = TRUE;
 140
 141         /* cli setting */
 142         if (_vc_core_util_extract_call_number_without_cli(callobject_info.source_tel_number, setupCallInfo.szNumber, sizeof(setupCallInfo.szNumber)) == FALSE) {
 143                 CALL_ENG_DEBUG(ENG_DEBUG, "No proper number = %s", callobject_info.source_tel_number);
 144                 return FALSE;
 145         }
 146         CALL_ENG_DEBUG(ENG_DEBUG, "tapi callnum=[%s]", setupCallInfo.szNumber);
 147
 148
 149         /* CUG settings */
 150 #ifdef _TAPI_CUG_
 151         setupCallInfo.pCugInfo = &pCugInfo;
 152         if (FALSE == callobject_info.cug_info.bcug_used) {
 153                 setupCallInfo.pCugInfo->bCugFlag = FALSE;
 154         } else {
 155                 setupCallInfo.pCugInfo->bCugFlag = TRUE;
 156                 /*if the index is 0, use pref cug, so no cug index */
 157                 if (0 == callobject_info.cug_info.cug_index) {
 158                         setupCallInfo.pCugInfo->Option = TAPI_CALL_CUG_NO_INFO;
 159                         setupCallInfo.pCugInfo->Index = 0;
 160                 } else {
 161                         if ((FALSE == callobject_info.cug_info.bpref_cug) && (FALSE == callobject_info.cug_info.boa_cug)) {
 162                                 setupCallInfo.pCugInfo->Option = TAPI_CALL_CUG_SUPRESS_OA_AND_CUG;
 163                         } else if (FALSE == callobject_info.cug_info.bpref_cug) {
 164                                 setupCallInfo.pCugInfo->Option = TAPI_CALL_CUG_SUPRESS_PRF_CUG;
 165                         } else if (FALSE == callobject_info.cug_info.boa_cug) {
 166                                 setupCallInfo.pCugInfo->Option = TAPI_CALL_CUG_SUPRESS_OA;
 167                         } else {
 168                                 setupCallInfo.pCugInfo->Option = TAPI_CALL_CUG_NO_INFO;
 169                         }
 170                         setupCallInfo.pCugInfo->Index = callobject_info.cug_info.cug_index;
 171                 }
 172         }
 173 #endif
 174
 175 #ifdef _CPHS_DEFINED_
 176         if (TRUE == _vc_core_svcall_cphs_csp_get_status(pcall_agent, VC_CPHS_CSP_ALS)) {
 177                 if (callobject_info.setupBy == VC_CALL_SETUP_BY_MAILBOX) {
 178                         if (callobject_info.alsLine == VC_CALL_CPHS_ALS_LINE1) {
 179                                 tel_set_call_act_line(TAPI_CALL_ACTIVE_LINE1, &ReqId);
 180                         } else if (callobject_info.alsLine == VC_CALL_CPHS_ALS_LINE2) {
 181                                 tel_set_call_act_line(TAPI_CALL_ACTIVE_LINE2, &ReqId);
 182                         } else {
 183                                 CALL_ENG_DEBUG(ENG_DEBUG, "callobject_info.alsLine invalid value=%d", callobject_info.alsLine);
 184                                 tel_set_call_act_line(TAPI_CALL_ACTIVE_LINE1, &ReqId);
 185                         }
 186                 } else {
 187                         /*read the line information from the dynamic flags */
 188                         voice_call_cphs_alsline_t als_line;
 189                         callobject_info.alsLine = _vc_core_svcall_get_cphs_als_active_line(pcall_agent);
 190                         tel_set_call_act_line(callobject_info.alsLine);
 191                         _vc_core_cm_set_outgoing_call_info(&pcall_agent->call_manager, &callobject_info);
 192                 }
 193         } else {
 194                 CALL_ENG_DEBUG(ENG_DEBUG, "ACtive Line Set is TAPI_ACTIVE_LINE1");
 195                 tel_set_call_act_line(TAPI_CALL_ACTIVE_LINE1, &ReqId);
 196         }
 197 #endif
 198
 199         CALL_ENG_DEBUG(ENG_DEBUG, "call_type = %d", setupCallInfo.CallType);
 200
 201         CALL_ENG_DEBUG(ENG_DEBUG, "Call Type by Source: %d", callobject_info.call_type);
 202         if (VC_CALL_ORIG_TYPE_SAT == callobject_info.call_type) {
 203                 /*setupCallInfo.bRequestedBySAT = TRUE;*/
 204         } else {
 205                 /*setupCallInfo.bRequestedBySAT = FALSE;*/
 206         }
 207         /*CALL_ENG_DEBUG(ENG_DEBUG,"Call Initiated by SAT: %d",setupCallInfo.bRequestedBySAT);*/
 208
 209         CALL_ENG_KPI("tel_exe_call_mo start");
 210         /*This Function originates MO Call set-up, This is asynchronous function */
 211         tapi_err = tel_exe_call_mo(&setupCallInfo, (TS_UINT *) &call_handle, &ReqId);
 212         CALL_ENG_KPI("tel_exe_call_mo done");
 213
 214         CALL_ENG_DEBUG(ENG_DEBUG, "ReqId is = %d", ReqId);
 215
 216         if (TAPI_API_SUCCESS != tapi_err) {
 217                 CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_setup failed: Error Code: %d", tapi_err);
 218                 return FALSE;
 219         } else {
 220                 CALL_ENG_DEBUG(ENG_DEBUG, "call_handle = %d", call_handle);
 221
 222                 /* Set the Call Handle to the CallbObject for future reference */
 223                 callobject_info.call_handle = call_handle;
 224
 225                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_OUTGOING);
 226                 callobject_info.call_id = _vc_core_cm_get_new_callId(&pcall_agent->call_manager);
 227
 228                 _vc_core_cm_set_outgoing_call_info(&pcall_agent->call_manager, &callobject_info);
 229
 230                 CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 231         }
 232         return TRUE;
 233 }
 234
 235  /**
 236  * This function answers the call
 237  *
 238  * @return              Returns TRUE on success and FALSE on failure
 239  * @param[in]           pcall_agent                     Pointer to the call agent state
 240  * @param[in]           answer_type     call answer type #voicecall_answer_type_t
 241  * @param[out]  error_code      Error code
 242  */
 243 gboolean _vc_core_tapi_rqst_answer_call(call_vc_callagent_state_t *pcall_agent, voicecall_answer_type_t answer_type, int *error_code)
 244 {
 245         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 246         /*Encapsulates Errors and Warnings from TAPI Library */
 247         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 248         int ReqId = VC_RQSTID_DEFAULT;
 249         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 250         VOICECALL_RETURN_FALSE_IF_FAIL(error_code != NULL);
 251
 252         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 253
 254         if ((VC_INOUT_STATE_INCOME_WAIT_CONNECTED == pcall_agent->io_state)
 255             || (VC_INOUT_STATE_INCOME_WAIT_HOLD_CONNECTED == pcall_agent->io_state)
 256             || (VC_INOUT_STATE_INCOME_WAIT_RELEASE_ACTIVE_CONNECTED == pcall_agent->io_state))
 257                 /*||(VC_INOUT_STATE_INCOME_WAIT_RELEASE_HOLDCALL == pcall_agent->io_state))*/
 258         {
 259                 CALL_ENG_DEBUG(ENG_DEBUG, "Answer Call Request Already Made");
 260                 *error_code = ERROR_VOICECALL_PREVIOUS_REQUEST_IN_PROGRESS;
 261                 return FALSE;
 262         }
 263
 264         /*
 265            Process the answer call request only when the state is in income and it is not ended.
 266            This must be checked as both incoming event and incoming end event from tapi are added to g_idle_add
 267            so any change in state should be noted before accepting the call
 268         */
 269         if ((VC_INOUT_STATE_INCOME_BOX != pcall_agent->io_state) || (VC_INOUT_STATE_INCOME_END == pcall_agent->io_state)) {
 270                 CALL_ENG_DEBUG(ENG_DEBUG, "IO State not in VC_INOUT_STATE_INCOME_BOX, Current state: %d", pcall_agent->io_state);
 271                 *error_code = ERROR_VOICECALL_PREVIOUS_REQUEST_IN_PROGRESS;
 272                 return FALSE;
 273         }
 274
 275         _vc_core_cm_clear_endcall_member(&pcall_agent->call_manager);
 276         call_handle = _vc_core_cm_get_incoming_call_handle(&pcall_agent->call_manager);
 277
 278         CALL_ENG_DEBUG(ENG_DEBUG, "answer_type = %d,Incoming call Handle: %d", answer_type, call_handle);
 279         if (VC_TAPI_INVALID_CALLHANDLE == call_handle) {
 280                 *error_code = ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 281                 return FALSE;
 282         }
 283
 284         switch (answer_type) {
 285         case VC_ANSWER_NORMAL:
 286                 {
 287                         /*Answer a call by accepting or rejecting a call */
 288                         tapi_err = tel_answer_call(call_handle, TAPI_CALL_ANSWER_ACCEPT, &ReqId);
 289                         if (TAPI_API_SUCCESS == tapi_err) {
 290                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_CONNECTED);
 291                         }
 292                 }
 293                 break;
 294         case VC_ANSWER_HOLD_ACTIVE_AND_ACCEPT:
 295                 {
 296                         /*Answer a call by accepting or rejecting a call */
 297                         tapi_err = tel_answer_call(call_handle, TAPI_CALL_ANSWER_HOLD_AND_ACCEPT, &ReqId);
 298                         if (TAPI_API_SUCCESS == tapi_err) {
 299                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_HOLD_CONNECTED);
 300                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_HOLD);
 301                         }
 302                 }
 303                 break;
 304         case VC_ANSWER_RELEASE_ACTIVE_AND_ACCEPT:
 305                 {
 306                         /*Answer a call by accepting or rejecting a call */
 307                         tapi_err = tel_answer_call(call_handle, TAPI_CALL_ANSWER_REPLACE, &ReqId);
 308                         if (TAPI_API_SUCCESS == tapi_err) {
 309                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_RELEASE_ACTIVE_CONNECTED);
 310                         }
 311                 }
 312                 break;
 313         case VC_ANSWER_RELEASE_HOLD_AND_ACCEPT:
 314                 {
 315                         /* first end held call and then accept incoming */
 316                         if (TRUE == _vc_core_tapi_rqst_release_held_calls(pcall_agent)) {
 317                                 CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_tapi_rqst_release_held_calls returns TRUE");
 318                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_RELEASE_HOLDCALL);
 319                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_RELEASE_ALL_HOLDCALL);
 320                         }
 321                         return TRUE;
 322                 }
 323                 break;
 324 #ifdef RELEASE_ALL_AND_ACCEPT_SUPPORT
 325         case VC_ANSWER_RELEASE_ALL_AND_ACCEPT:
 326                 {
 327                         /* first (end held call) and then ( release accept and accept ) */
 328                         if (TRUE == _vc_core_tapi_rqst_release_held_calls(pcall_agent)) {
 329                                 CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_tapi_rqst_release_held_calls returns TRUE");
 330                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_RELEASE_HOLDCALL_FOR_ALL_RELEASE);
 331                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_RELEASE_ALL_HOLDCALL);
 332                         }
 333                         return TRUE;
 334                 }
 335                 break;
 336 #endif
 337         default:
 338                 {
 339                         *error_code = ERROR_VOICECALL_NOT_SUPPORTED;
 340                         return FALSE;
 341                 }
 342         }
 343
 344         if (TAPI_API_SUCCESS != tapi_err) {
 345                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
 346                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_answer_call failed ,Error Code:%d", tapi_err);
 347                 *error_code = ERROR_VOICECALL_ANSWER_FAILED;
 348                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_answer_call failed ,Engine Error Code:%d", *error_code);
 349                 return FALSE;
 350         }
 351
 352         return TRUE;
 353 }
 354
 355 /**
 356  * This function checks and prepares to accept a call
 357  *
 358  * @return              Returns TRUE on success and FALSE on failure
 359  * @param[in]           pcall_agent                     Pointer to the call agent state
 360  */
 361 gboolean _vc_core_tapi_rqst_response_call(call_vc_callagent_state_t *pcall_agent)
 362 {
 363         gboolean active_call, held_call, incoming_call;
 364         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 365
 366         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 367
 368         active_call = _vc_core_cm_isexists_active_call(&pcall_agent->call_manager);
 369         held_call = _vc_core_cm_isexists_held_call(&pcall_agent->call_manager);
 370         incoming_call = _vc_core_cm_isexists_incoming_call(&pcall_agent->call_manager);
 371
 372         if (active_call && held_call) {
 373                 CALL_ENG_DEBUG(ENG_DEBUG, "Show EndCallChoice Box");
 374                 return TRUE;
 375         } else if (active_call) {
 376                 CALL_ENG_DEBUG(ENG_DEBUG, "Case of bActiceCall...");
 377                 /* if there are active call, after hold call can accept mtc */
 378                 /* set the flag and return */
 379                 /*Although TapiHold failed, keep on going( because , when active call is ended, TapiHold failed then ansercall is possible... only when Tapihold succeed, state is changed to WAIT_HOLD*/
 380                 if (_vc_core_tapi_rqst_hold_call(pcall_agent) == TRUE) {
 381                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_HOLD);
 382                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_HOLD);
 383                         return TRUE;
 384                 }
 385         } else if (incoming_call == FALSE) {
 386                 CALL_ENG_DEBUG(ENG_DEBUG, "No Call Available");
 387                 return FALSE;
 388         }
 389
 390         CALL_ENG_DEBUG(ENG_DEBUG, "Calling tapi_call_respond_recall(call_handle = %d, TRUE) ...", call_handle);
 391
 392         return TRUE;
 393 }
 394
 395 /**
 396  * This function releases active calls
 397  *
 398  * @return              Returns TRUE on success and FALSE on failure
 399  * @param[in]           pcall_agent                     Pointer to the call agent state
 400  */
 401 gboolean _vc_core_tapi_rqst_release_active_calls(call_vc_callagent_state_t *pcall_agent)
 402 {
 403         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 404         int pReqId = VC_RQSTID_DEFAULT;
 405         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 406         int nPos;
 407         int nCount = 0;
 408         call_vc_call_objectinfo_t callobject_info = { 0 };
 409
 410         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 411         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 412 #ifdef NEW_TAPI_API
 413         nPos = _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
 414
 415         if (call_handle != -1) {
 416                 CALL_ENG_DEBUG(ENG_DEBUG, "First Active call_handle = %d", call_handle);
 417 #ifdef SINGLE_CALL_END
 418                 if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 419                         CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 420
 421                         /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 422                         tapi_err = tel_release_call_all(&pReqId);
 423                 } else
 424 #endif
 425                 {
 426                         tapi_err = tel_release_call_all_active(&pReqId);
 427                 }
 428
 429                 if (TAPI_API_SUCCESS != tapi_err) {
 430                         CALL_ENG_DEBUG(ENG_DEBUG, "Release All Active Failed call_handle=%d Error Code:%d...", call_handle, tapi_err);
 431                         return FALSE;
 432                 } else {
 433                         CALL_ENG_DEBUG(ENG_DEBUG, "pReqId = %d", pReqId);
 434                         while (nPos != -1) {
 435                                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 436                                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_RELEASE_WAIT);
 437                                 _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 438
 439                                 nPos = _vc_core_cm_get_next_active_call_handle(&pcall_agent->call_manager, &call_handle, nPos);
 440                         }
 441
 442                         return TRUE;
 443                 }
 444         } else {
 445                 CALL_ENG_DEBUG(ENG_DEBUG, "No Active calls available");
 446                 return FALSE;
 447         }
 448 #else
 449         gcall_vc_callmember_count = 0;
 450
 451         nPos = _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
 452
 453         _vc_core_cm_clear_call_object(&callobject_info);
 454         while (nPos != -1) {
 455                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 456
 457                 if (callobject_info.state == VC_CALL_STATE_CONNECTED) {
 458 #ifdef SINGLE_CALL_END
 459                         if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 460                                 CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 461
 462                                 /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 463                                 tapi_err = tel_release_call_all(&pReqId);
 464                         } else
 465 #endif
 466                         {
 467                                 /*Releases the call identified by Call Handle irrespective of call is hold or active state */
 468                                 tapi_err = tel_release_call(call_handle, &pReqId);
 469                         }
 470
 471                         if (TAPI_API_SUCCESS != tapi_err) {
 472                                 CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_relese Failed call_handle=%d Error Code:%d...", call_handle, tapi_err);
 473                                 return FALSE;
 474                         } else {
 475                                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_RELEASE_WAIT);
 476                                 _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 477                                 nCount++;
 478                         }
 479                 }
 480                 nPos = _vc_core_cm_get_next_active_call_handle(&pcall_agent->call_manager, &call_handle, nPos);
 481         }
 482
 483         gcall_vc_callmember_count = nCount;
 484         if (gcall_vc_callmember_count > 0) {
 485                 gcall_vc_callend_wait = TRUE;
 486                 return TRUE;
 487         } else {
 488                 CALL_ENG_DEBUG(ENG_DEBUG, "There is no active call to release..");
 489                 return FALSE;
 490         }
 491 #endif
 492 }
 493
 494 /**
 495  * This function releases held calls
 496  *
 497  * @return              Returns TRUE on success and FALSE on failure
 498  * @param[in]           pcall_agent                     Pointer to the call agent state
 499  */
 500 gboolean _vc_core_tapi_rqst_release_held_calls(call_vc_callagent_state_t *pcall_agent)
 501 {
 502         int nPos;
 503         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 504         call_vc_call_objectinfo_t callobject_info = { 0 };
 505         int nCount = 0;
 506         int pReqId = VC_RQSTID_DEFAULT;
 507         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 508
 509         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 510         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 511 #ifdef NEW_TAPI_API
 512         nPos = _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &call_handle);
 513
 514         if (call_handle != -1) {
 515                 CALL_ENG_DEBUG(ENG_DEBUG, "First Held call_handle = %d", call_handle);
 516 #ifdef SINGLE_CALL_END
 517                 if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 518                         CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 519
 520                         /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 521                         tapi_err = tel_release_call_all(&pReqId);
 522                 } else
 523 #endif
 524                 {
 525                         tapi_err = tel_release_call_all_held(&pReqId);
 526                 }
 527
 528                 if (TAPI_API_SUCCESS != tapi_err) {
 529                         CALL_ENG_DEBUG(ENG_DEBUG, "Release All Held Failed call_handle=%d Error Code:%d...", call_handle, tapi_err);
 530                         return FALSE;
 531                 } else {
 532                         CALL_ENG_DEBUG(ENG_DEBUG, "pReqId = %d", pReqId);
 533                         while (nPos != -1) {
 534                                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 535                                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_RELEASE_WAIT);
 536                                 _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 537
 538                                 nPos = _vc_core_cm_get_next_held_call_handle(&pcall_agent->call_manager, &call_handle, nPos);
 539                         }
 540
 541                         return TRUE;
 542                 }
 543         } else {
 544                 CALL_ENG_DEBUG(ENG_DEBUG, "No Held calls available");
 545                 return FALSE;
 546         }
 547 #else
 548         gcall_vc_callmember_count = 0;
 549
 550         nPos = _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &call_handle);
 551
 552         _vc_core_cm_clear_call_object(&callobject_info);
 553         while (nPos != -1) {
 554                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 555
 556                 if (callobject_info.state == VC_CALL_STATE_CONNECTED) {
 557 #ifdef SINGLE_CALL_END
 558                         if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 559                                 CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 560
 561                                 /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 562                                 tapi_err = tel_release_call_all(&pReqId);
 563                         } else
 564 #endif
 565                         {
 566                                 /*Releases the call identified by Call Handle irrespective of call is hold or active state */
 567                                 tapi_err = tel_release_call(call_handle, &pReqId);
 568                         }
 569
 570                         if (TAPI_API_SUCCESS != tapi_err) {
 571                                 CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_relese Failed call_handle=%d Error Code:%d...", call_handle, tapi_err);
 572                                 return FALSE;
 573                         } else {
 574                                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_RELEASE_WAIT);
 575                                 _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 576                                 nCount++;
 577                         }
 578                 }
 579                 nPos = _vc_core_cm_get_next_held_call_handle(&pcall_agent->call_manager, &call_handle, nPos);
 580         }
 581
 582         gcall_vc_callmember_count = nCount;
 583         if (gcall_vc_callmember_count > 0) {
 584                 gcall_vc_callend_wait = TRUE;
 585                 return TRUE;
 586         } else {
 587                 CALL_ENG_DEBUG(ENG_DEBUG, "There is no held call to release..");
 588                 return FALSE;
 589         }
 590 #endif
 591 }
 592
 593 /**
 594  * This function releases all calls
 595  *
 596  * @return              Returns TRUE on success and FALSE on failure
 597  * @param[in]           pcall_agent                     Pointer to the call agent state
 598  */
 599 gboolean _vc_core_tapi_rqst_release_all_calls(call_vc_callagent_state_t *pcall_agent)
 600 {
 601         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 602         int pReqId = VC_RQSTID_DEFAULT;
 603         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 604
 605         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 606
 607         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 608
 609         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
 610         CALL_ENG_DEBUG(ENG_DEBUG, "call_handle:[%d]..", call_handle);
 611
 612         if (VC_TAPI_INVALID_CALLHANDLE == call_handle) {
 613                 _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &call_handle);
 614         }
 615
 616         if (VC_TAPI_INVALID_CALLHANDLE == call_handle) {
 617                 CALL_ENG_DEBUG(ENG_DEBUG, "invalid call handle");
 618                 return FALSE;
 619         }
 620
 621         /*Releases All calls irrespective of call is in hold or active state */
 622         tapi_err = tel_release_call_all(&pReqId);
 623         if (TAPI_API_SUCCESS != tapi_err) {
 624                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_release_call_all failed: Error _Code: %d", tapi_err);
 625                 return FALSE;
 626         }
 627
 628         return TRUE;
 629 }
 630
 631 /**
 632  * This function releases the incoming call
 633  *
 634  * @return              Returns TRUE on success and FALSE on failure
 635  * @param[in]           pcall_agent                     Pointer to the call agent state
 636  */
 637 gboolean _vc_core_tapi_rqst_release_incoming_call(call_vc_callagent_state_t *pcall_agent)
 638 {
 639         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 640         int pReqId = VC_RQSTID_DEFAULT;
 641         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 642
 643         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 644
 645         call_handle = _vc_core_cm_get_incoming_call_handle(&pcall_agent->call_manager);
 646         if (VC_TAPI_INVALID_CALLHANDLE == call_handle)
 647                 return FALSE;
 648
 649 #ifdef SINGLE_CALL_END
 650         if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 651                 CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 652
 653                 /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 654                 tapi_err = tel_release_call_all(&pReqId);
 655         } else
 656 #endif
 657         {
 658                 /*Releases the call identified by Call Handle irrespective of call is hold or active state */
 659                 tapi_err = tel_release_call(call_handle, &pReqId);
 660         }
 661
 662         if (TAPI_API_SUCCESS != tapi_err) {
 663                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_release_call() call_handle=%d Failed, Error Code: %d...", call_handle, tapi_err);
 664                 return FALSE;
 665         }
 666
 667         _vc_core_cm_change_call_object_state(&pcall_agent->call_manager, call_handle, VC_CALL_STATE_REJECTED);
 668
 669         return TRUE;
 670
 671 }
 672
 673 /**
 674  * This function releases outgoing call
 675  *
 676  * @return              Returns TRUE on success and FALSE on failure
 677  * @param[in]           pcall_agent                     Pointer to the call agent state
 678  */
 679 gboolean _vc_core_tapi_rqst_release_outgoing_call(call_vc_callagent_state_t *pcall_agent)
 680 {
 681
 682         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 683         int pReqId = VC_RQSTID_DEFAULT;
 684         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 685
 686         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 687
 688         call_handle = _vc_core_cm_get_outgoing_call_handle(&pcall_agent->call_manager);
 689
 690         if (VC_TAPI_INVALID_CALLHANDLE == call_handle)
 691                 return FALSE;
 692
 693 #ifdef SINGLE_CALL_END
 694         if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
 695                 CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
 696
 697                 /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
 698                 tapi_err = tel_release_call_all(&pReqId);
 699         } else
 700 #endif
 701         {
 702                 /*Releases the call identified by Call Handle irrespective of call is hold or active state */
 703                 tapi_err = tel_release_call(call_handle, &pReqId);
 704         }
 705
 706         if (TAPI_API_SUCCESS != tapi_err) {
 707                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_release_call Failed call_handle=%d Error Code:%d", call_handle, tapi_err);
 708                 return FALSE;
 709         }
 710
 711         _vc_core_cm_change_call_object_state(&pcall_agent->call_manager, call_handle, VC_CALL_STATE_CANCELLED);
 712
 713         return TRUE;
 714 }
 715
 716 /**
 717  * This function holds a call
 718  *
 719  * @return              Returns TRUE on success and FALSE on failure
 720  * @param[in]           pcall_agent                     Pointer to the call agent structure
 721  */
 722 gboolean _vc_core_tapi_rqst_hold_call(call_vc_callagent_state_t *pcall_agent)
 723 {
 724         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 725         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 726         int ReqId = VC_RQSTID_DEFAULT;
 727
 728         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 729
 730         /*Get the current active call handle and hold it*/
 731         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
 732         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 733                 CALL_ENG_DEBUG(ENG_DEBUG, "ERROR: No active call available");
 734                 return FALSE;
 735         }
 736
 737         CALL_ENG_DEBUG(ENG_DEBUG, "calling tapi_call_hold, Current active call = %d...", call_handle);
 738
 739         /* Hold the call */
 740         /*Puts the given call on hold */
 741         tapi_err = tel_hold_call(call_handle, &ReqId);
 742         if (TAPI_API_SUCCESS != tapi_err) {
 743                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_hold_call() Failed Error Code: %d", tapi_err);
 744                 return FALSE;
 745         }
 746
 747         return TRUE;
 748 }
 749
 750 /**
 751  * This function retrieves a call from hold
 752  *
 753  * @return              Returns TRUE on success and FALSE on failure
 754  * @param[in]           pcall_agent                     Pointer to the call agent structure
 755  */
 756 gboolean _vc_core_tapi_rqst_retrieve_call(call_vc_callagent_state_t *pcall_agent)
 757 {
 758         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 759         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 760         int ReqId = VC_RQSTID_DEFAULT;
 761
 762         CALL_ENG_DEBUG(ENG_DEBUG, "...");
 763         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 764
 765         _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &call_handle);
 766         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 767                 CALL_ENG_DEBUG(ENG_DEBUG, "No Hold Call Error...");
 768                 return FALSE;
 769         }
 770
 771         CALL_ENG_DEBUG(ENG_DEBUG, "Cur held call_handle = %d.", call_handle);
 772         /* activate the call */
 773         /*This function retrieves the held call */
 774         tapi_err = tel_retrieve_call(call_handle, &ReqId);
 775         if (TAPI_API_SUCCESS != tapi_err) {
 776                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_retrieve_call() Failed, Error Code: %d", tapi_err);
 777                 return FALSE;
 778         }
 779
 780         return TRUE;
 781 }
 782
 783 /**
 784  * This function swaps held and active calls
 785  *
 786  * @return              Returns TRUE on success and FALSE on failure
 787  * @param[in]           pcall_agent                     Pointer to the call agent structure
 788  */
 789 gboolean _vc_core_tapi_rqst_swap_calls(call_vc_callagent_state_t *pcall_agent)
 790 {
 791         call_vc_handle active_call = VC_TAPI_INVALID_CALLHANDLE, held_call = VC_TAPI_INVALID_CALLHANDLE;
 792         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 793         int ReqId = VC_RQSTID_DEFAULT;
 794
 795         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 796         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 797
 798         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_call);
 799         if (active_call == VC_TAPI_INVALID_CALLHANDLE) {
 800                 CALL_ENG_DEBUG(ENG_DEBUG, "No Active Call...");
 801                 return FALSE;
 802         }
 803
 804         _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &held_call);
 805         if (held_call == VC_TAPI_INVALID_CALLHANDLE) {
 806                 CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_tapi_rqst_swap_calls: No Hold Call...");
 807                 return FALSE;
 808         }
 809
 810         CALL_ENG_DEBUG(ENG_DEBUG, "Current Active call = %d, Hold call :%d", active_call, held_call);
 811
 812         tapi_err = tel_swap_call(active_call, held_call, &ReqId);
 813         if (TAPI_API_SUCCESS != tapi_err) {
 814                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_swap_call() Failed, Error Code: %d", tapi_err);
 815                 return FALSE;
 816         }
 817
 818         return TRUE;
 819 }
 820
 821 /**
 822  * This function joins two calls
 823  *
 824  * @return              Returns TRUE on success and FALSE on failure
 825  * @param[in]           pcall_agent             Pointer to the call agent structure
 826  */
 827 gboolean _vc_core_tapi_rqst_join_calls(call_vc_callagent_state_t *pcall_agent)
 828 {
 829         call_vc_handle active_call = VC_TAPI_INVALID_CALLHANDLE, held_call = VC_TAPI_INVALID_CALLHANDLE;
 830         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 831         int ReqId = VC_RQSTID_DEFAULT;
 832
 833         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 834
 835         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_call);
 836         if (active_call == VC_TAPI_INVALID_CALLHANDLE) {
 837                 CALL_ENG_DEBUG(ENG_DEBUG, "No Active Call");
 838                 return FALSE;
 839         }
 840
 841         _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &held_call);
 842         if (held_call == VC_TAPI_INVALID_CALLHANDLE) {
 843                 CALL_ENG_DEBUG(ENG_DEBUG, "No Hold Call");
 844                 return FALSE;
 845         }
 846
 847         CALL_ENG_DEBUG(ENG_DEBUG, "Current Active call = %d, Hold call :%d", active_call, held_call);
 848         /*This functions joins given two calls */
 849         tapi_err = tel_join_call(active_call, held_call, &ReqId);
 850         if (TAPI_API_SUCCESS != tapi_err) {
 851                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_join_call() Failed, Error Code: %d", tapi_err);
 852                 return FALSE;
 853         }
 854
 855         return TRUE;
 856 }
 857
 858 /**
 859  * This function splits the members of a call given its call handle
 860  *
 861  * @return              Returns TRUE on success and FALSE on failure
 862  * @param[in]           pcall_agent             Pointer to the call agent structure
 863  * @param[in]           call_handle     Call handle for a call the members of which has to be split
 864  */
 865 gboolean _vc_core_tapi_rqst_private_call(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle)
 866 {
 867
 868         if (TRUE == __call_vc_split_member(call_handle)) {
 869                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_SPLIT);
 870                 return TRUE;
 871         } else {
 872                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 873                 return FALSE;
 874         }
 875 }
 876
 877 static gboolean __call_vc_split_member(call_vc_handle call_handle)
 878 {
 879         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 880         int ReqId = VC_RQSTID_DEFAULT;
 881
 882         CALL_ENG_DEBUG(ENG_DEBUG, "...");
 883         VOICECALL_RETURN_FALSE_IF_FAIL(call_handle != VC_TAPI_INVALID_CALLHANDLE);
 884
 885         CALL_ENG_DEBUG(ENG_DEBUG, "call_handle to be splited : %d", call_handle);
 886
 887         /*Splits a private call from multiparty call. */
 888         tapi_err = tel_split_call(call_handle, &ReqId);
 889         if (TAPI_API_SUCCESS != tapi_err) {
 890                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_split_call() Failed, Error Code: %d", tapi_err);
 891                 return FALSE;
 892         }
 893
 894         return TRUE;
 895 }
 896
 897 /**
 898  * This function transfers call
 899  *
 900  * @return              Returns TRUE on success and FALSE on failure
 901  * @param[in]           pcall_agent             Pointer to the call agent structure
 902  */
 903 gboolean _vc_core_tapi_rqst_transfer_call(call_vc_callagent_state_t *pcall_agent)
 904 {
 905         call_vc_handle active_call = VC_TAPI_INVALID_CALLHANDLE;
 906         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 907         int ReqId = VC_RQSTID_DEFAULT;
 908
 909         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 910
 911         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_call);
 912         if (active_call == VC_TAPI_INVALID_CALLHANDLE) {
 913                 CALL_ENG_DEBUG(ENG_DEBUG, "No Active Call...");
 914
 915                 active_call = _vc_core_cm_get_outgoing_call_handle(&pcall_agent->call_manager);
 916                 if (VC_TAPI_INVALID_CALLHANDLE == active_call) {
 917                         CALL_ENG_DEBUG(ENG_DEBUG, "No Outgoing Call...");
 918                         return FALSE;
 919                 } else
 920                         CALL_ENG_DEBUG(ENG_DEBUG, "Outgoing call exist..!!");
 921         }
 922         CALL_ENG_DEBUG(ENG_DEBUG, "active_call = %d ", active_call);
 923
 924         /*An explicit call transfer by connecting the two parties where in one party being
 925            active (active state) and another party being held (held state) */
 926         tapi_err = tel_exe_call_explicit_transfer(active_call, &ReqId);
 927         if (TAPI_API_SUCCESS != tapi_err) {
 928                 CALL_ENG_DEBUG(ENG_DEBUG, "tel_exe_call_explicit_transfer() Failed, Error Code: %d", tapi_err);
 929                 return FALSE;
 930         }
 931
 932         return TRUE;
 933 }
 934
 935 /**
 936  * This function sends the given string as dtmf
 937  *
 938  * @return              Returns TRUE on success and FALSE on failure
 939  * @param[in]           pcall_agent             Pointer to the call agent structure
 940  * @param[in]           dtmf_string     dtmf string
 941  */
 942 gboolean _vc_core_tapi_rqst_start_dtmf(call_vc_callagent_state_t *pcall_agent, char *dtmf_string)
 943 {
 944         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 945         TapiResult_t tapi_err = TAPI_API_SUCCESS;
 946         int ReqId = VC_RQSTID_DEFAULT;
 947
 948         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 949
 950         CALL_ENG_DEBUG(ENG_DEBUG, "Start DTMF!! string = %s", dtmf_string);
 951
 952         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
 953
 954         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 955                 CALL_ENG_DEBUG(ENG_DEBUG, "No Active Call Handle..");
 956                 return FALSE;
 957         }
 958
 959         CALL_ENG_DEBUG(ENG_DEBUG, "string = %s", dtmf_string);
 960
 961         /* start DTMF */
 962         /*This function sends one or more DTMF digits during call */
 963         tapi_err = tel_send_call_dtmf(dtmf_string, &ReqId);
 964
 965         if (TAPI_API_SUCCESS != tapi_err) {
 966                 CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_dtmf Failed, Error Code: %d", tapi_err);
 967                 return FALSE;
 968         }
 969
 970         CALL_ENG_DEBUG(ENG_DEBUG, " Ended...");
 971
 972         return TRUE;
 973
 974 }
 975
 976 #ifdef _SEND_UUSINFO_
 977 /**
 978  * This function sends user to user information
 979  *
 980  * @return              Returns TRUE on success and FALSE on failure
 981  * @param[in]           pcall_agent             Pointer to the call agent state
 982  * @param[in]           call_handle     The call handle for which the information has to be sent
 983  * @param[in]           pszUusData      User data
 984  */
 985 gboolean call_vc_send_uusinfo(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, char *pszUusData)
 986 {
 987         TelCallUusInfo_t uusInfo;
 988         int nPos;
 989
 990         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 991
 992         memset(&uusInfo, 0, sizeof(TelCallUusInfo_t));
 993
 994         uusInfo.bMoreDataPresent = FALSE;       /*more_data_present = FALSE;*/
 995         uusInfo.ProtocolType = TAPI_CALL_UUS_PROTO_SPECIFIC;
 996         uusInfo.UusType = TAPI_CALL_UUS_1;
 997         uusInfo.UusDataLen = strlen(pszUusData);
 998
 999         _vc_core_util_strcpy((char *)uusInfo.UusData, sizeof(uusInfo.UusData), pszUusData);
1000
1001         nPos = _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &call_handle);
1002         while (nPos != -1) {
1003                 /*TAPI API not available to send user info */
1004                 /*tapi doen't supprot this api.*/
1005                 /******************************************************************************************
1006                 tapi_err = tapi_call_send_user_info(call_handle, &uusInfo);
1007                 if (TAPI_API_SUCCESS != tapi_err) {
1008                         CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_send_user_info() Failed,Error Code: %d", tapi_err);
1009                         return FALSE;
1010                 }
1011                 ******************************************************************************************/
1012                 nPos = _vc_core_cm_get_next_active_call_handle(&pcall_agent->call_manager, &call_handle, nPos);
1013         }
1014
1015         return TRUE;
1016 }
1017 #endif
1018
1019 /**
1020  * This function releases the call associate with the given call handle
1021  *
1022  * @return              Returns TRUE on success and FALSE on failure
1023  * @param[in]           pcall_agent                     Pointer to the call agent state
1024  * @param[in]           call_handle     handle of the call to be ended
1025  */
1026 gboolean _vc_core_tapi_rqst_end_call_by_callhandle(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle)
1027 {
1028         call_vc_call_objectinfo_t callobject_info;
1029         int pReqId = VC_RQSTID_DEFAULT;
1030         TapiResult_t tapi_err = TAPI_API_SUCCESS;
1031
1032         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1033
1034         if (FALSE == _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info)) {
1035                 CALL_ENG_DEBUG(ENG_DEBUG, "Call Object not available for call handle: %d", call_handle);
1036                 return FALSE;
1037
1038         }
1039
1040         if (VC_CALL_STATE_CONNECTED == callobject_info.state) {
1041 #ifdef SINGLE_CALL_END
1042                 if (_vc_core_cm_get_call_member_count(&pcall_agent->call_manager) == 1) {
1043                         CALL_ENG_DEBUG(ENG_DEBUG, "End Single call..");
1044
1045                         /* Use ReleaseAll api in case single call is ended - this is caused by modem limitation */
1046                         tapi_err = tel_release_call_all(&pReqId);
1047                 } else
1048 #endif
1049                 {
1050                         /*Releases the call identified by Call Handle irrespective of call is hold or active state */
1051                         tapi_err = tel_release_call(call_handle, &pReqId);
1052                 }
1053
1054                 if (TAPI_API_SUCCESS != tapi_err) {
1055                         CALL_ENG_DEBUG(ENG_DEBUG, "tapi_call_release Failed Call Handle: %d, Error Code: %d", call_handle, tapi_err);
1056                         return FALSE;
1057                 }
1058
1059                 _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_RELEASE_WAIT);
1060                 _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
1061                 return TRUE;
1062         }
1063
1064         return FALSE;
1065 }
1066
1067 /**
1068  * This function ends a call
1069  *
1070  * @return              Returns TRUE on success and FALSE on failure
1071  * @param[in]           pcall_agent             Pointer to the call agent state
1072  */
1073 gboolean _vc_core_tapi_rqst_end_call(call_vc_callagent_state_t *pcall_agent)
1074 {
1075         gboolean ret_val = FALSE;
1076
1077         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1078
1079         CALL_ENG_DEBUG(ENG_DEBUG, "..");
1080
1081         switch (pcall_agent->callagent_state) {
1082         case CALL_VC_CA_STATE_NORMAL:
1083         case CALL_VC_CA_STATE_WAIT_HOLD:
1084         case CALL_VC_CA_STATE_WAIT_UNHOLD:
1085                 {
1086
1087                         if (_vc_core_cm_isexists_active_call(&pcall_agent->call_manager)) {
1088                                 ret_val = _vc_core_tapi_rqst_release_active_calls(pcall_agent);
1089                                 if (TRUE == ret_val) {
1090                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_RELEASE_ALL_ACTIVECALL);
1091                                 }
1092                         } else if (_vc_core_cm_isexists_held_call(&pcall_agent->call_manager)) {
1093                                 ret_val = _vc_core_tapi_rqst_release_held_calls(pcall_agent);
1094                                 if (TRUE == ret_val) {
1095                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_RELEASE_ALL_HOLDCALL);
1096                                 }
1097                         } else {
1098                                 _vc_core_cm_clear_endcall_member(&pcall_agent->call_manager);
1099                         }
1100                 }
1101                 break;
1102         default:
1103                 CALL_ENG_DEBUG(ENG_DEBUG, "No Action defined for current call agent state: %d", pcall_agent->callagent_state);
1104                 return FALSE;
1105         }
1106
1107         return TRUE;
1108 }
1109
1110 /**
1111  * This function rejects a mobile terminated call
1112  *
1113  * @return              Returns TRUE on success and FALSE on failure
1114  * @param[in]           pcall_agent     Pointer to the call agent state
1115  * @param[in]           budub           TRUE - User Determined User Busy, FALSE - otherwise
1116  * @param[out]  error_code      Error code
1117  */
1118 gboolean _vc_core_tapi_rqst_reject_mt_call(call_vc_callagent_state_t *pcall_agent, gboolean budub, int *error_code)
1119 {
1120         call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
1121         TapiResult_t tapi_err = TAPI_API_SUCCESS;
1122         int pReqId = VC_RQSTID_DEFAULT;
1123
1124         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1125
1126         CALL_ENG_DEBUG(ENG_DEBUG, "budub = %d", budub);
1127         if (_vc_core_cm_isexists_incoming_call(&pcall_agent->call_manager) == FALSE) {
1128                 CALL_ENG_DEBUG(ENG_DEBUG, "Incoming call does not exist");
1129                 *error_code = ERROR_VOICECALL_NO_INCOMING_CALL_EXIST;
1130                 return FALSE;
1131         }
1132
1133         if (pcall_agent->io_state == VC_INOUT_STATE_INCOME_WAIT_RELEASE) {
1134                 CALL_ENG_DEBUG(ENG_DEBUG, " io_state is already VC_INOUT_STATE_INCOME_WAIT_RELEASE");
1135                 /*return TRUE since call release has been already done and it is waiting for the release*/
1136                 return TRUE;
1137         }
1138
1139         if (pcall_agent->io_state == VC_INOUT_STATE_NONE) {
1140                 CALL_ENG_DEBUG(ENG_DEBUG, "return FALSE io_state=%d", pcall_agent->io_state);
1141                 *error_code = ERROR_VOICECALL_ENGINE_STATE_NONE;
1142                 return FALSE;
1143         }
1144
1145         call_handle = _vc_core_cm_get_incoming_call_handle(&pcall_agent->call_manager);
1146
1147         if (TRUE == budub) {
1148                 /*Reject the Call for User Busy Scenario */
1149                 tapi_err = tel_answer_call(call_handle, TAPI_CALL_ANSWER_REJECT, &pReqId);
1150
1151                 if (TAPI_API_SUCCESS != tapi_err) {
1152                         CALL_ENG_DEBUG(ENG_DEBUG, " tel_answer_call failed: %d", tapi_err);
1153                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
1154                         *error_code = ERROR_VOICECALL_TAPI_ERROR;
1155                         return FALSE;
1156                 }
1157         } else {
1158                 /*Release the call to end it normally */
1159                 if (FALSE == _vc_core_tapi_rqst_release_incoming_call(pcall_agent)) {
1160                         CALL_ENG_DEBUG(ENG_ERR, "Release Incoming Call Failed");
1161                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
1162                         *error_code = ERROR_VOICECALL_TAPI_ERROR;
1163                         return FALSE;
1164                 }
1165         }
1166
1167         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_RELEASE);
1168         return TRUE;
1169 }