call-engine/core/vc-core-tapi-evnt.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 <string.h>
  19 #include <assert.h>
  20 #include "vc-core-tapi-evnt.h"
  21 #include "vc-core-callmanager.h"
  22 #include "vc-core-util.h"
  23 #include "vc-core-tapi-rqst.h"
  24
  25 /**
  26 * This function processes the current io wait states if  available
  27 *
  28 * @internal
  29 * @return               if wait states are processed, FALSE otherwise
  30 * @param[in]            pcall_agent             handle to voicecall agent structure
  31 */
  32 static gboolean __call_vc_process_wait_state_success_events(call_vc_callagent_state_t *pcall_agent);
  33
  34 /**
  35 * This function requests the TAPI for the ppm value for callcost
  36 *
  37 * @internal
  38 * @return               void
  39 * @param[in]            pcall_agent             handle to voicecall agent structure
  40 */
  41 static void __call_vc_get_aoc_ppm_value(call_vc_callagent_state_t *pcall_agent);
  42 static gboolean __call_vc_get_aoc_ppm_value_idle_cb(gpointer pdata);
  43 static gboolean __call_vc_download_call_timer_cb(gpointer pdata);
  44
  45 /**
  46  * This function retreives the voicecall engine specific end cause type for the given TAPI end cause type
  47  *
  48  * @return              Returns TRUE on success and FALSE on failure
  49  * @param[in]           type                            TAPI event type
  50  * @param[in]           cause                   TAPI call end cause
  51  * @param[out]  end_cause_type  voicecall engine end cause
  52  */
  53 void _vc_core_tapi_event_get_end_cause_type(call_vc_callagent_state_t *pcall_agent, const char *noti_id, TelTapiEndCause_t cause, voice_call_end_cause_type_t *end_cause_type)
  54 {
  55         VOICECALL_RETURN_IF_FAIL(end_cause_type != NULL);
  56
  57         CALL_ENG_DEBUG(ENG_DEBUG, "EventType:[%s],EndCause:%d", noti_id, cause);
  58
  59         if (strcmp(noti_id, TAPI_NOTI_VOICE_CALL_STATUS_IDLE) == 0) {
  60                 switch (cause) {
  61                 case TAPI_CC_CAUSE_NORMAL_UNSPECIFIED:
  62                         *end_cause_type = VC_ENDCAUSE_CALL_DISCONNECTED;
  63                         break;
  64                 case TAPI_CC_CAUSE_FACILITY_REJECTED:
  65                         *end_cause_type = VC_ENDCAUSE_CALL_FAILED;
  66                         break;
  67                 case TAPI_CC_CAUSE_QUALITY_OF_SERVICE_UNAVAILABLE:
  68                 case TAPI_CC_CAUSE_ACCESS_INFORMATION_DISCARDED:
  69                 case TAPI_CC_CAUSE_BEARER_CAPABILITY_NOT_AUTHORISED:
  70                 case TAPI_CC_CAUSE_BEARER_CAPABILITY_NOT_PRESENTLY_AVAILABLE:
  71                 case TAPI_CC_CAUSE_SERVICE_OR_OPTION_NOT_AVAILABLE:
  72                 case TAPI_CC_CAUSE_BEARER_SERVICE_NOT_IMPLEMENTED:
  73                 case TAPI_CC_CAUSE_PROTOCOL_ERROR_UNSPECIFIED:
  74
  75                         *end_cause_type = VC_ENDCAUSE_CALL_ENDED;
  76                         break;
  77
  78                 case TAPI_CC_CAUSE_REQUESTED_FACILITY_NOT_SUBSCRIBED:
  79                         *end_cause_type = VC_ENDCAUSE_CALL_SERVICE_NOT_ALLOWED;
  80                         break;
  81
  82                 case TAPI_CC_CAUSE_OPERATOR_DETERMINED_BARRING:
  83                         *end_cause_type = VC_ENDCAUSE_CALL_BARRED;
  84                         break;
  85                 case TAPI_REJECT_CAUSE_MM_REJ_NO_SERVICE:
  86                         *end_cause_type = VC_ENDCAUSE_NO_SERVICE;
  87                         break;
  88
  89                 case TAPI_REJECT_CAUSE_CONGESTTION:
  90                 case TAPI_REJECT_CAUSE_CNM_REJ_NO_RESOURCES:
  91                 case TAPI_CC_CAUSE_SWITCHING_EQUIPMENT_CONGESTION:      /* Match as NW_BUSY*/
  92                         *end_cause_type = VC_ENDCAUSE_NW_BUSY;
  93                         break;
  94
  95                 case TAPI_REJECT_CAUSE_NETWORK_FAILURE:
  96                 case TAPI_REJECT_CAUSE_MSC_TEMPORARILY_NOT_REACHABLE:
  97                         *end_cause_type = VC_ENDCAUSE_NW_FAILED;
  98                         break;
  99
 100                 case TAPI_REJECT_CAUSE_IMEI_NOT_ACCEPTED:
 101                         {
 102                                 unsigned long mcc = 0;
 103
 104                                 _vc_core_util_get_mcc(&mcc);
 105
 106                                 if (mcc == CALL_NETWORK_MCC_UK) {
 107                                         *end_cause_type = VC_ENDCAUSE_IMEI_REJECTED;    /*Display "Please verify SIM or insert valid SIM"*/
 108                                 } else {
 109                                         *end_cause_type = VC_ENDCAUSE_NW_FAILED;        /*Display Network unavailable*/
 110                                 }
 111                         }
 112                         break;
 113
 114                 case TAPI_CC_CAUSE_NO_ROUTE_TO_DEST:
 115                 case TAPI_CC_CAUSE_TEMPORARY_FAILURE:
 116                 case TAPI_CC_CAUSE_NETWORK_OUT_OF_ORDER:
 117                 case TAPI_CC_CAUSE_REQUESTED_CIRCUIT_CHANNEL_NOT_AVAILABLE:
 118                 case TAPI_CC_CAUSE_NO_CIRCUIT_CHANNEL_AVAILABLE:
 119                 case TAPI_CC_CAUSE_DESTINATION_OUT_OF_ORDER:
 120                         *end_cause_type = VC_ENDCAUSE_SERVICE_TEMP_UNAVAILABLE;
 121                         break;
 122                 case TAPI_CC_CAUSE_NO_USER_RESPONDING:
 123                 case TAPI_CC_CAUSE_USER_ALERTING_NO_ANSWER:
 124                         *end_cause_type = VC_ENDCAUSE_USER_DOESNOT_RESPOND;
 125                         break;
 126
 127                 case TAPI_CC_CAUSE_ACM_GEQ_ACMMAX:
 128                         *end_cause_type = VC_ENDCAUSE_NO_CREDIT;
 129                         break;
 130
 131                 case TAPI_CC_CAUSE_CALL_REJECTED:
 132                         if (pcall_agent->barring_ind_type == VC_BARR_IND_ALL)
 133                                 *end_cause_type = VC_ENDCAUSE_CALL_BARRED;
 134                         else
 135                                 *end_cause_type = VC_ENDCAUSE_USER_UNAVAILABLE;
 136
 137                         pcall_agent->barring_ind_type = VC_BARR_IND_NONE;
 138                         break;
 139
 140                 case TAPI_CC_CAUSE_USER_BUSY:
 141                         *end_cause_type = VC_ENDCAUSE_USER_BUSY;
 142                         break;
 143
 144                 case TAPI_CC_CAUSE_USER_NOT_MEMBER_OF_CUG:
 145                         *end_cause_type = VC_ENDCAUSE_WRONG_GROUP;
 146                         break;
 147
 148                 case TAPI_CC_CAUSE_INVALID_NUMBER_FORMAT:
 149
 150                         *end_cause_type = VC_ENDCAUSE_INVALID_NUMBER_FORMAT;
 151                         break;
 152
 153                 case TAPI_CC_CAUSE_UNASSIGNED_NUMBER:
 154                         *end_cause_type = VC_ENDCAUSE_UNASSIGNED_NUMBER;
 155                         break;
 156
 157                 case TAPI_CC_CAUSE_NUMBER_CHANGED:
 158                         *end_cause_type = VC_ENDCAUSE_NUMBER_CHANGED;
 159                         break;
 160
 161                 case TAPI_CALL_END_NO_CAUSE:
 162                 default:
 163                         *end_cause_type = VC_ENDCAUSE_CALL_ENDED;
 164
 165                         CALL_ENG_DEBUG(ENG_ERR, "Call Ended or Default Cause Value: %d", cause);
 166                         break;
 167                 }
 168         } else {
 169                 *end_cause_type = VC_ENDCAUSE_CALL_FAILED;
 170                 CALL_ENG_DEBUG(ENG_DEBUG, "Invalid call end cause or error !!");
 171         }
 172
 173         CALL_ENG_DEBUG(ENG_DEBUG, "Engine End Cause: %d", (int)*end_cause_type);
 174 }
 175
 176 void _vc_core_tapi_event_copy_incoming_call_data(call_vc_callagent_state_t *pcall_agent, TelCallIncomingCallInfo_t *callInfo, call_vc_call_objectinfo_t *pcallobject_info)
 177 {
 178 #ifdef _CPHS_DEFINED_
 179         if (_vc_core_svcall_cphs_csp_get_status(pcall_agent, VC_CPHS_CSP_ALS)) {
 180                 TelCallActiveLine_t activeLine = callInfo->ActiveLine;
 181
 182                 if (activeLine == TAPI_CALL_ACTIVE_LINE1) {
 183                         pcallobject_info->alsLine = VC_CALL_CPHS_ALS_LINE1;
 184                 } else if (activeLine == TAPI_CALL_ACTIVE_LINE2) {
 185                         pcallobject_info->alsLine = VC_CALL_CPHS_ALS_LINE2;
 186                 } else {
 187                         CALL_ENG_DEBUG(ENG_DEBUG, "undefined currentLine=%d", activeLine);
 188                 }
 189         }
 190 #endif
 191
 192         _vc_core_util_strcpy(pcallobject_info->calling_name, sizeof(pcallobject_info->calling_name), callInfo->CallingNameInfo.szNameData);
 193         pcallobject_info->bcalling_namemode = callInfo->CallingNameInfo.NameMode;
 194
 195         /* If BCD number exists, number should be shown even though number restriction is set */
 196         if (strlen(callInfo->szCallingPartyNumber) > 0) {
 197                 pcallobject_info->brestricted_namemode = FALSE;
 198
 199                 if (callInfo->szCallingPartyNumber[0] == '*') {
 200                         pcallobject_info->bccbs_call = TRUE;
 201                         _vc_core_util_strcpy(pcallobject_info->tel_number, sizeof(pcallobject_info->tel_number), callInfo->szCallingPartyNumber + 1);
 202                 } else {
 203                         _vc_core_util_strcpy(pcallobject_info->tel_number, sizeof(pcallobject_info->tel_number), callInfo->szCallingPartyNumber);
 204                 }
 205
 206                 /* check callInfo->name_mode if override category isn't supported.*/
 207         } else {                /* If BCD number doesn't exist, cause_of_no_cli value should be checked to decide its presentation */
 208
 209                 pcallobject_info->brestricted_namemode = TRUE;
 210
 211 /*code clean: #ifndef _ARM_SP*/
 212                 pcallobject_info->name_mode = callInfo->CliCause;
 213
 214                 CALL_ENG_DEBUG(ENG_DEBUG, "no_cli_cause = %d, name_mode = %d...", callInfo->CliCause, pcallobject_info->name_mode);
 215         }
 216 }
 217
 218 /**
 219  * This function handles the incoming event
 220  *
 221  * @return              Returns TRUE on success and FALSE on failure
 222  * @param[in]           pcall_agent             Pointer to the call agent state
 223  * @param[in]           call_handle             Incoming call handle
 224  * @param[in]           callInfo                        Incoming call info associated with the incoming call
 225  */
 226 gboolean _vc_core_tapi_event_handle_incoming_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallIncomingCallInfo_t *callInfo)
 227 {
 228         call_vc_call_objectinfo_t callobject_info;
 229         int callIndex;
 230
 231         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 232
 233         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, number = %s..", call_handle, callInfo->szCallingPartyNumber);
 234
 235         /* setting the new member info */
 236         _vc_core_cm_clear_call_object(&callobject_info);
 237
 238         callobject_info.call_handle = call_handle;
 239         callobject_info.call_id = _vc_core_cm_get_new_callId(&pcall_agent->call_manager);
 240         callobject_info.bincoming_call_is_fwded = callInfo->fwded;
 241
 242         /* setting the incom call telephone number */
 243         CALL_ENG_DEBUG(ENG_DEBUG, "[callobject_info.call_handle=%d], FWDED Call: %d", callobject_info.call_handle, callobject_info.bincoming_call_is_fwded);
 244
 245         /*Copy Incoming call data in to the callobject */
 246         _vc_core_tapi_event_copy_incoming_call_data(pcall_agent, callInfo, &callobject_info);
 247
 248         /*Change the Call Object Call State*/
 249         _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_INCOME);
 250
 251         /*Add the newly created callobject to the Call Manager*/
 252         callIndex = _vc_core_cm_add_call_object(&pcall_agent->call_manager, &callobject_info);
 253         if (callIndex != -1) {
 254                 /*Set the Call Manager's MT Call Index as CallObject Index*/
 255                 if (FALSE == _vc_core_cm_set_incoming_call(&pcall_agent->call_manager, callIndex)) {
 256                         CALL_ENG_DEBUG(ENG_ERR, "Problem in accpeting the incoming call, Current Call Details");
 257                         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 258                         return FALSE;
 259                 }
 260         } else {
 261                 CALL_ENG_DEBUG(ENG_ERR, "Problem in adding the call to the call manager");
 262                 CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 263         }
 264
 265         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_START);
 266
 267         return TRUE;
 268 }
 269
 270 /**
 271  * This function handles TAPI alert event
 272  *
 273  * @return              Returns TRUE on success and FALSE on failure
 274  * @param[in]           pcall_agent             Pointer to the call agent state
 275  * @param[in]           call_handle             Call Handle associated with the alert event
 276  */
 277 gboolean _vc_core_tapi_event_handle_alert_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle)
 278 {
 279         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 280
 281         /* Verify call handle */
 282         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d", call_handle);
 283
 284         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 285                 CALL_ENG_DEBUG(ENG_ERR, "INVALID_CALLHANDLE Error");
 286                 return FALSE;
 287         }
 288
 289         _vc_core_cm_change_call_object_state(&pcall_agent->call_manager, call_handle, VC_CALL_STATE_OUTGOING_ALERT);
 290
 291         /* Change Inout state to "wait connected" before sending event to client so the same state is
 292            reflected in client side also */
 293         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_CONNECTED);
 294
 295         /*Send Alert Event to Client*/
 296         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_OUTGOING_ALERT, call_handle, 0, NULL);
 297         return TRUE;
 298 }
 299
 300 /**
 301  * This function handles TAPI origination event
 302  *
 303  * @return              Returns TRUE on success and FALSE on failure
 304  * @param[in]           pcall_agent             Pointer to the call agent state
 305  * @param[in]           call_handle             Call Handle associated with the alert event
 306  */
 307 gboolean _vc_core_tapi_event_handle_originated_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle)
 308 {
 309         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 310         VOICECALL_RETURN_FALSE_IF_FAIL(call_handle > 0);
 311
 312         /* Verify call handle */
 313         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d", call_handle);
 314
 315         _vc_core_cm_change_call_object_state(&pcall_agent->call_manager, call_handle, VC_CALL_STATE_OUTGOING_ORIG);
 316
 317         /* Send Alert Event to Client */
 318         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_OUTGOING_ORIG, call_handle, 0, NULL);
 319
 320         /* Change Inout state to "wait Alert" */
 321         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_ALERT);
 322
 323         /* send response here.. not connected ind. Disable checking gcf status. */
 324 #ifndef _vc_core_ca_send_sat_response_ORIG
 325         if (TRUE == _vc_core_util_check_gcf_status())
 326 #endif
 327         {
 328                 call_vc_call_objectinfo_t callobject_info;
 329
 330                 _vc_core_cm_clear_call_object(&callobject_info);
 331
 332                 /*Process Connected Event*/
 333                 /* Get the member info and chage info */
 334                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 335
 336                 if (callobject_info.call_type == VC_CALL_ORIG_TYPE_SAT) {
 337                         _vc_core_ca_send_sat_response(pcall_agent, SAT_RQST_SETUP_CALL, CALL_VC_ME_RET_SUCCESS);
 338                 }
 339         }
 340
 341         return TRUE;
 342 }
 343
 344 /**
 345  * This function handles the call end event
 346  *
 347  * @return              Returns TRUE on success and FALSE on failure
 348  * @param[in]           pcall_agent             Pointer to the call agent state
 349  * @param[in]           type                            TAPI Event Type
 350  * @param[in]           handle                  Call Handle of the call being ended
 351  * @param[in]           cause                   TAPI End Cause
 352  */
 353 gboolean _vc_core_tapi_event_handle_call_end_event(call_vc_callagent_state_t *pcall_agent, const char * noti_id, call_vc_handle handle, TelTapiEndCause_t cause)
 354 {
 355         gboolean active_call = FALSE;
 356         gboolean held_call = FALSE;
 357         int error_code = 0;
 358         call_vc_call_objectinfo_t callobject_info;
 359         voicecall_call_state_t prev_callstate;
 360
 361         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 362
 363         _vc_core_cm_get_call_object(&pcall_agent->call_manager, handle, &callobject_info);
 364
 365         prev_callstate = callobject_info.state;
 366
 367         _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_ENDED);
 368
 369         /* set end cause text*/
 370         _vc_core_tapi_event_get_end_cause_type(pcall_agent, noti_id, cause, &callobject_info.end_cause_type);
 371
 372         /*Set the modified CallObject to the Call Manager*/
 373         _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 374
 375         /*All calls are disconnected, so stop call timer*/
 376         if (_vc_core_cm_isexists_connected_call(&pcall_agent->call_manager) == FALSE) {
 377                 CALL_ENG_DEBUG(ENG_DEBUG, "No Connected Call Exist");
 378         }
 379
 380         active_call = _vc_core_cm_isexists_active_call(&pcall_agent->call_manager);
 381         held_call = _vc_core_cm_isexists_held_call(&pcall_agent->call_manager);
 382
 383         switch (pcall_agent->callagent_state) {
 384         case CALL_VC_CA_STATE_WAIT_JOIN:
 385                 if ((FALSE == active_call) || (FALSE == held_call)) {
 386                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 387                 }
 388                 break;
 389         case CALL_VC_CA_STATE_WAIT_HOLD:
 390                 if (FALSE == active_call) {
 391                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 392                 }
 393                 break;
 394         case CALL_VC_CA_STATE_WAIT_UNHOLD:
 395                 if (FALSE == held_call) {
 396                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 397                 }
 398                 break;
 399         case CALL_VC_CA_STATE_WAIT_SWAP:
 400                 if ((FALSE == active_call) || (FALSE == held_call)) {
 401                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 402                 }
 403                 break;
 404         case CALL_VC_CA_STATE_WAIT_RELEASE_ALL_ACTIVECALL:
 405 #ifdef AUTO_RETREIVE_HELD_CALL
 406                 if (FALSE == active_call) {
 407                         /* todo call: IF Ear MIC is Inserted && */
 408                         if ((TRUE == held_call) && (pcall_agent->io_state == VC_INOUT_STATE_NONE) && \
 409                                         (TRUE == _vc_core_tapi_rqst_retrieve_call(pcall_agent))) {
 410                                 _vc_core_cm_clear_endcall_member(&pcall_agent->call_manager);
 411
 412                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ACTION_CALL_END_HELD_RETREIVED, handle, 0, NULL);
 413
 414                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_UNHOLD);
 415                         } else {
 416                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 417                         }
 418                 }
 419 #else
 420                 if (FALSE == active_call) {
 421                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 422                 } else {
 423                         CALL_ENG_DEBUG(ENG_DEBUG, "Still Active Calls are available");
 424                 }
 425 #endif
 426                 break;
 427         case CALL_VC_CA_STATE_WAIT_RELEASE_ALL_HOLDCALL:
 428                 if (FALSE == held_call) {
 429                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 430                 }
 431                 break;
 432         case CALL_VC_CA_STATE_WAIT_RELEASE_ALL_CALLS:
 433                 if ((active_call == FALSE) && (held_call == FALSE)) {
 434                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 435                 }
 436                 break;
 437         case CALL_VC_CA_STATE_SS_WAIT_RELEASE_ALL_ACTIVECALL:
 438                 CALL_ENG_DEBUG(ENG_DEBUG, "Retrieve held call on active call end");
 439                 if (FALSE == active_call) {
 440                         if ((TRUE == held_call) && (TRUE == _vc_core_tapi_rqst_retrieve_call(pcall_agent))) {
 441                                 _vc_core_cm_clear_endcall_member(&pcall_agent->call_manager);
 442                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ACTION_CALL_END_HELD_RETREIVED, handle, 0, NULL);
 443                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_UNHOLD);
 444                         } else {
 445                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 446                         }
 447                 }
 448                 break;
 449         case CALL_VC_CA_STATE_WAIT_DROP:
 450                 if (VC_CALL_STATE_RELEASE_WAIT == prev_callstate) {
 451                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 452                 }
 453
 454                 break;
 455
 456         case CALL_VC_CA_STATE_SPLIT_CALLBOX:
 457         case CALL_VC_CA_STATE_DROP_CALLBOX:
 458         case CALL_VC_CA_STATE_SENDMSG_CALLBOX:
 459         case CALL_VC_CA_STATE_SAVE_TO_CONTACT_CALLBOX:
 460         case CALL_VC_CA_STATE_VIEW_CONTACT_DETAIL_CALLBOX:
 461                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 462                 break;
 463         case CALL_VC_CA_STATE_WAIT_RELEASE_ALL_CALLS_TO_SWITCH_TO_VIDEO_CALL:
 464                 if ((FALSE == active_call) && (FALSE == held_call)) {
 465                         char tel_number[VC_PHONE_NUMBER_LENGTH_MAX];
 466
 467                         memset(tel_number, 0, VC_PHONE_NUMBER_LENGTH_MAX);
 468                 }
 469                 break;
 470         case CALL_VC_CA_STATE_WAIT_RELEASE_ALL_CALLS_TO_SETUP:
 471                 {
 472                         if ((active_call == FALSE) && (held_call == FALSE)) {
 473                                 call_vc_call_objectinfo_t callInfo;
 474                                 call_vc_handle call_handle = VC_TAPI_INVALID_CALLHANDLE;
 475
 476                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 477                                 if (_vc_core_tapi_rqst_setup_call(pcall_agent) == FALSE) {
 478                                         if (_vc_core_cm_get_outgoing_call_info(&pcall_agent->call_manager, &callInfo)) {
 479                                                 /*Send response only if call type is sat */
 480                                                 if (callInfo.call_type == VC_CALL_ORIG_TYPE_SAT) {
 481                                                         CALL_ENG_DEBUG(ENG_DEBUG, "SAT_CALL fail to setup call");
 482                                                         _vc_core_ca_send_sat_response(pcall_agent, SAT_RQST_SETUP_CALL, CALL_VC_ME_UNABLE_TO_PROCESS_COMMAND);
 483                                                 }
 484                                         }
 485                                         break;
 486                                 }
 487
 488                                 /*Update CallManager State */
 489                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_ORIG);
 490                                 call_handle = _vc_core_cm_get_outgoing_call_handle(&pcall_agent->call_manager);
 491                                 CALL_ENG_DEBUG(ENG_DEBUG, "Deffered Outgoing Call Handle = %d", call_handle);
 492
 493                                 /*Inform Client about the Deferred Outgoing */
 494                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_OUTGOING, call_handle, 0, NULL);
 495                         }
 496                 }
 497                 break;
 498         case CALL_VC_CA_STATE_WAIT_TRANSFER_CNF:
 499                 {
 500                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 501                         CALL_ENG_DEBUG(ENG_DEBUG, "Waiting transfer canceled!");
 502                 }
 503                 break;
 504         default:
 505                 CALL_ENG_DEBUG(ENG_DEBUG, "Action not defined for this call agent state:%d", pcall_agent->callagent_state);
 506         }
 507
 508         /* if waiting call end for mtc */
 509         switch (pcall_agent->io_state) {
 510         case VC_INOUT_STATE_INCOME_WAIT_HOLD:
 511
 512                 if (active_call == FALSE) {
 513                         CALL_ENG_DEBUG(ENG_DEBUG, "call to hold is disconnected..proceed to answer call");
 514                         /*It will be better to show end of call
 515                         _vc_core_tapi_rqst_answer_call( pcall_agent);*/
 516                 }
 517
 518                 break;
 519
 520         case VC_INOUT_STATE_INCOME_WAIT_RELEASE_ACTIVECALL:
 521                 if (active_call == FALSE) {
 522                         /*_vc_core_tapi_rqst_answer_call( pcall_agent);*/
 523                 }
 524                 break;
 525         case VC_INOUT_STATE_INCOME_WAIT_RELEASE_HOLDCALL:
 526                 if (held_call == FALSE) {
 527                         CALL_ENG_DEBUG(ENG_DEBUG, "Answering call after ending held calls");
 528
 529                         /*Change the state to Income box, so the answer API will process it */
 530                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_BOX);
 531
 532                         /* end held call and then accept incoming call */
 533                         _vc_core_tapi_rqst_answer_call(pcall_agent, VC_ANSWER_HOLD_ACTIVE_AND_ACCEPT, &error_code);
 534                 }
 535                 break;
 536 #ifdef RELEASE_ALL_AND_ACCEPT_SUPPORT
 537         case VC_INOUT_STATE_INCOME_WAIT_RELEASE_HOLDCALL_FOR_ALL_RELEASE:
 538                 if (held_call == FALSE) {
 539                         CALL_ENG_DEBUG(ENG_DEBUG, "Answering(rel and accept) call after ending held calls");
 540
 541                         /*Change the state to Income box, so the answer API will process it */
 542                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_BOX);
 543
 544                         /* end held call and then accept incoming call */
 545                         _vc_core_tapi_rqst_answer_call(pcall_agent, VC_ANSWER_RELEASE_ACTIVE_AND_ACCEPT, &error_code);
 546                 }
 547                 break;
 548 #endif
 549         case VC_INOUT_STATE_OUTGOING_WAIT_HOLD:
 550                 _vc_core_cm_clear_outgoing_call(&pcall_agent->call_manager);
 551                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_ABORTED);
 552                 break;
 553         default:
 554                 CALL_ENG_DEBUG(ENG_DEBUG, "No Actions defined for IO State: %d", pcall_agent->io_state);
 555         }
 556
 557         if (VC_CALL_ORIG_TYPE_SAT == callobject_info.call_type) {
 558                 if (pcall_agent->call_manager.setupcall_info.satcall_setup_info.psat_rgb_data != NULL) {
 559                         free(pcall_agent->call_manager.setupcall_info.satcall_setup_info.psat_rgb_data);
 560                         pcall_agent->call_manager.setupcall_info.satcall_setup_info.psat_rgb_data = NULL;
 561                 }
 562         }
 563
 564         return TRUE;
 565 }
 566
 567 static gboolean __call_vc_process_wait_state_success_events(call_vc_callagent_state_t *pcall_agent)
 568 {
 569         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 570         switch (pcall_agent->io_state) {
 571         case VC_INOUT_STATE_INCOME_WAIT_HOLD_CONNECTED:
 572                 {
 573                         int grp_index;
 574                         call_vc_handle active_handle = VC_TAPI_INVALID_CALLHANDLE;
 575
 576                         if (pcall_agent->callagent_state == CALL_VC_CA_STATE_WAIT_HOLD) {
 577                                 CALL_ENG_DEBUG(ENG_DEBUG, "Separate HOLD_CNF event not arrived for HOLD and ACCEPT request, holding the call in the CONNECTED event");
 578                                 grp_index = _vc_core_cm_get_active_group_index(&pcall_agent->call_manager);
 579
 580                                 if (-1 == grp_index) {
 581                                         CALL_ENG_DEBUG(ENG_DEBUG, " ERROR:No Active Grp Index :grp_index = %d, Active state has been already held, check io state", grp_index);
 582                                         return TRUE;
 583                                 }
 584
 585                                 _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_handle);
 586
 587                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, grp_index, CALL_VC_GROUP_STATE_HOLD);
 588
 589                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 590
 591                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_HELD, active_handle, 0, NULL);
 592
 593                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_CONNECTED);
 594                         }
 595                 }
 596                 break;
 597
 598 #ifdef _INCOME_WAIT_CONNECTED_
 599         /*currently not applied, Fix to change the group state to hold, if the second call is connected before getting the holdcnf resp from tapi */
 600         case VC_INOUT_STATE_INCOME_WAIT_CONNECTED:
 601                 {
 602                         /*Check for incoming call exists */
 603                         if (VC_INVALID_CALL_INDEX == pcall_agent->call_manager.mtcall_index) {
 604                                 CALL_ENG_DEBUG(ENG_DEBUG, "No Incoming call exists");
 605                                 return TRUE;
 606                         }
 607
 608                         if (0 == _vc_core_cm_get_connected_member_count_ingroup(&pcall_agent->call_manager, 0)) {
 609                                 CALL_ENG_DEBUG(ENG_DEBUG, "No Previous Connected Members");
 610                                 return TRUE;
 611                         }
 612
 613                         /*Connected Event for the incoming call is arrived, when waiting for hold confirmation
 614                            So change the active call state to hold before processing the connected indication */
 615                         if (CALL_VC_CA_STATE_WAIT_HOLD == pcall_agent->callagent_state) {
 616                                 int grp_index;
 617                                 /*call_vc_handle active_handle =TAPI_INVALID_CALLHANDLE;*/
 618                                 grp_index = _vc_core_cm_get_active_group_index(&pcall_agent->call_manager);
 619
 620                                 if (-1 == grp_index) {
 621                                         CALL_ENG_DEBUG(ENG_DEBUG, " ERROR:No Active Grp Index :grp_index = %d, Active state has been already held, check io state", grp_index);
 622                                         return TRUE;
 623                                 }
 624                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 625                                 /*_vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager,&active_handle);*/
 626                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, grp_index, CALL_VC_GROUP_STATE_HOLD);
 627                         } else if (CALL_VC_CA_STATE_WAIT_UNHOLD == pcall_agent->callagent_state) {
 628                                 int grp_index;
 629                                 call_vc_handle held_handle = VC_TAPI_INVALID_CALLHANDLE;
 630                                 grp_index = _vc_core_cm_get_held_group_index(&pcall_agent->call_manager);
 631                                 if (-1 == grp_index) {
 632                                         CALL_ENG_DEBUG(ENG_DEBUG, " ERROR:No Active Grp Index :grp_index = %d, Active state has been already held, check io state", grp_index);
 633                                         return TRUE;
 634                                 }
 635                                 _vc_core_cm_get_first_held_call_handle(&pcall_agent->call_manager, &held_handle);
 636                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, grp_index, CALL_VC_GROUP_STATE_ACTIVE);
 637
 638                         }
 639                 }
 640                 break;
 641 #endif
 642         case VC_INOUT_STATE_INCOME_WAIT_RELEASE_ACTIVE_CONNECTED:
 643                 {
 644                         call_vc_handle active_handle = VC_TAPI_INVALID_CALLHANDLE;;
 645                         CALL_ENG_DEBUG(ENG_DEBUG, "VC_INOUT_STATE_INCOME_WAIT_RELEASE_ACTIVE_CONNECTED");
 646                         _vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_handle);
 647                         CALL_ENG_DEBUG(ENG_DEBUG, "Active Call Handle = %d", active_handle);
 648
 649                         /*_vc_core_tapi_event_handle_call_end_event(pcall_agent, TAPI_EVENT_CALL_END, active_handle, TAPI_CALL_END_NO_CAUSE);*/
 650                 }
 651                 break;
 652         default:
 653                 CALL_ENG_DEBUG(ENG_DEBUG, "Action not defined for this wait io state: %d", pcall_agent->io_state);
 654         }
 655
 656         return TRUE;
 657 }
 658
 659 /**
 660  * This function handles the TAPI call connect event
 661  *
 662  * @return              Returns TRUE on success and FALSE on failure
 663  * @param[in]           pcall_agent             Pointer to the call agent state
 664  * @param[in]           call_handle             call handle assoicated with the call being connected
 665  */
 666 gboolean _vc_core_tapi_event_handle_call_connect_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle)
 667 {
 668         call_vc_call_objectinfo_t callobject_info;
 669         int index;
 670         int connectednum = 0;
 671
 672         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 673
 674         /* Verify call handle */
 675         CALL_ENG_DEBUG(ENG_DEBUG, "Started, Call Handle = %d", call_handle);
 676
 677         _vc_core_cm_clear_call_object(&callobject_info);
 678         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 679                 CALL_ENG_DEBUG(ENG_ERR, "INVALID_CALLHANDLE Error");
 680                 return FALSE;
 681         }
 682
 683         /*First Process the wait state events before processing the connect event */
 684         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 685         __call_vc_process_wait_state_success_events(pcall_agent);
 686         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 687
 688         /*Process Connected Event*/
 689         /* Get the member info and chage info */
 690         _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
 691
 692         /*
 693          **     Reqeust from SAT. When GCF field is ON, send response when get a setup confirm.
 694          **     To send response to SAT faster...
 695          */
 696 #ifndef _vc_core_ca_send_sat_response_ORIG
 697         if (FALSE == _vc_core_util_check_gcf_status()) {
 698                 if (callobject_info.call_type == VC_CALL_ORIG_TYPE_SAT) {
 699                         _vc_core_ca_send_sat_response(pcall_agent, SAT_RQST_SETUP_CALL, CALL_VC_ME_RET_SUCCESS);
 700                 }
 701         }
 702 #endif
 703
 704         _vc_core_cm_change_call_state(&callobject_info, VC_CALL_STATE_CONNECTED);
 705
 706         VOICECALL_RETURN_FALSE_IF_FAIL(callobject_info.call_id != VC_INVALID_CALL_ID);
 707
 708         index = _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
 709         VOICECALL_RETURN_FALSE_IF_FAIL(index != -1);
 710
 711         connectednum = _vc_core_cm_get_connected_member_count_ingroup(&pcall_agent->call_manager, 0) + _vc_core_cm_get_connected_member_count_ingroup(&pcall_agent->call_manager, 1);
 712         CALL_ENG_DEBUG(ENG_DEBUG, "Connected Member Num before adding Connected call to group is :%d", connectednum);
 713
 714         /*If any previous calls are not cleared after end, clear it here so makes provision to add one more call to the call manager */
 715         _vc_core_cm_clear_endcall_member(&pcall_agent->call_manager);
 716
 717         /*Add the conneted call to the active group */
 718         if (FALSE == _vc_core_cm_add_call_member_togroup(&pcall_agent->call_manager, index)) {
 719                 CALL_ENG_DEBUG(ENG_ERR, "Call Object not added to the Group, [PROBLEM] !!!");
 720         }
 721
 722         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 723
 724         /* Send Connected Event to the Client */
 725         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_CONNECTED, callobject_info.call_handle, 0, NULL);
 726
 727         /* Once the Call is connected, change the InOut state to None */
 728         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
 729
 730         /*Getting AOC PPM Value is delayed to make the current flow faster by adding it to g_idle_add */
 731         g_idle_add(__call_vc_get_aoc_ppm_value_idle_cb, pcall_agent);
 732
 733         if (_vc_core_engine_status_get_download_call(pcall_agent) == TRUE) {
 734                 g_timeout_add(9000, __call_vc_download_call_timer_cb, pcall_agent);
 735
 736                 _vc_core_util_download_test_call("downloadcall_success");
 737         }
 738
 739         return TRUE;
 740 }
 741
 742 /**
 743  * This function handles call hold event
 744  *
 745  * @return              Returns TRUE on success and FALSE on failure
 746  * @param[in]           pcall_agent             Pointer to the call agent state
 747  * @param[in]           call_handle             call handle assoicated with the call being held
 748  * @param[in]           status                  TAPI cause incase of hold failed
 749  */
 750 gboolean _vc_core_tapi_event_handle_call_held_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallCause_t status)
 751 {
 752         call_vc_call_objectinfo_t callobject_info;
 753
 754         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 755
 756         CALL_ENG_DEBUG(ENG_DEBUG, "");
 757
 758         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
 759
 760         /* Verify call handle */
 761         CALL_ENG_DEBUG(ENG_DEBUG, "Started, Call Handle = %d, status = %d", call_handle, status);
 762
 763         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 764                 CALL_ENG_DEBUG(ENG_DEBUG, "INVALID_CALLHANDLE Error");
 765                 return FALSE;
 766         }
 767
 768         if (TAPI_CAUSE_SUCCESS != status) {
 769                 switch (pcall_agent->io_state) {
 770                 case VC_INOUT_STATE_OUTGOING_WAIT_HOLD:
 771                         {
 772                                 /* Recover and reset related state variable */
 773                                 if (_vc_core_cm_get_outgoing_call_info(&pcall_agent->call_manager, &callobject_info) == FALSE) {
 774                                         CALL_ENG_DEBUG(ENG_DEBUG, "Outgoing call info does not exist");
 775                                         assert(0);
 776                                 }
 777
 778                                 if ((callobject_info.call_type == VC_CALL_ORIG_TYPE_SAT) && \
 779                                                 ((pcall_agent->call_manager.setupcall_info.satcall_setup_info.satengine_setupcall_data.calltype == \
 780                                                                 TAPI_SAT_SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD) || \
 781                                                                 (pcall_agent->call_manager.setupcall_info.satcall_setup_info.satengine_setupcall_data.calltype == \
 782                                                                                 TAPI_SAT_SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD_WITH_REDIAL))) {
 783
 784                                         /* Terminal Response for Option B */
 785                                         /* _vc_core_ca_send_sat_response(pcall_agent, SAT_RQST_SETUP_CALL, CALL_VC_NETWORK_UNABLE_TO_PROCESS_COMMAND); */
 786                                         /* Terminal Response for Option A */
 787                                         _vc_core_ca_send_sat_response(pcall_agent, SAT_RQST_SETUP_CALL, CALL_VC_NETWORK_UNABLE_TO_PROCESS_COMMAND_WITHOUT_CAUSE);
 788
 789                                 }
 790                                 _vc_core_cm_clear_outgoing_call(&pcall_agent->call_manager);
 791
 792                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_OUTGOING_ABORTED, VC_ENDCAUSE_CALL_ENDED, 0, NULL);
 793
 794                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_NONE);
 795                         }
 796                         break;
 797
 798                 case VC_INOUT_STATE_INCOME_WAIT_HOLD:
 799                         break;
 800
 801                 case VC_INOUT_STATE_NONE:
 802                         break;
 803
 804                 default:
 805                         CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_tapi_event_handle_call_held_event(fail): Not allowed io_state=%d", pcall_agent->io_state);
 806                         break;
 807                 }
 808
 809                 switch (pcall_agent->callagent_state) {
 810 #ifdef SWAP_SUPPORT
 811                 case CALL_VC_CA_STATE_WAIT_SWAP_HOLD_OR_ACTIVATE:
 812                         {
 813                                 /* Reset the Agent State */
 814                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 815                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SWAP_FAILED, 0, NULL);
 816                         }
 817                         break;
 818 #endif
 819                 case CALL_VC_CA_STATE_WAIT_SWAP:
 820                         {
 821                                 /* Reset the Agent State */
 822                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 823                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SWAP_FAILED, 0, NULL);
 824                         }
 825                         break;
 826                 case CALL_VC_CA_STATE_WAIT_HOLD:
 827                         {
 828                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 829                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_HOLD_FAILED, 0, NULL);
 830                         }
 831                         break;
 832                 case CALL_VC_CA_STATE_SS_WAIT_RELEASE_ALL_ACTIVECALL:
 833                         {
 834                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 835                         }
 836                         break;
 837                 case CALL_VC_CA_STATE_NORMAL:
 838                 default:        /*Fall Through */
 839                         CALL_ENG_DEBUG(ENG_DEBUG, "Not allowed callagent_state=%d", pcall_agent->callagent_state);
 840                         return FALSE;
 841                         break;
 842                 }
 843         } else {
 844                 int index;
 845                 int grp_state = 0;
 846
 847                 /* Get the Group Index */
 848                 index = _vc_core_cm_get_group_index(&pcall_agent->call_manager, call_handle);
 849                 grp_state = _vc_core_cm_get_group_state(&pcall_agent->call_manager, index);
 850
 851                 CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, GP_Index:%d, Cur Gp State: %d", call_handle, index, grp_state);
 852
 853                 switch (pcall_agent->io_state) {
 854                 case VC_INOUT_STATE_OUTGOING_WAIT_HOLD:
 855                         {
 856                                 /* Change the Group State */
 857                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_HOLD);
 858                                 CALL_ENG_DEBUG(ENG_DEBUG, "Gropu Index: %d , set to GROUP_STATE_HOLD", index);
 859
 860                                 /* Send Call Held Event to the Client */
 861                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_HELD, call_handle, 0, NULL);
 862
 863                                 if (_vc_core_tapi_rqst_setup_call(pcall_agent) == FALSE) {
 864                                         _vc_core_cm_clear_outgoing_call(&pcall_agent->call_manager);
 865                                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_ABORTED);
 866                                 } else {
 867                                         call_vc_handle outgoing_call_handle = VC_TAPI_INVALID_CALLHANDLE;
 868
 869                                         _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_OUTGOING_WAIT_ORIG);
 870                                         outgoing_call_handle = _vc_core_cm_get_outgoing_call_handle(&pcall_agent->call_manager);
 871                                         CALL_ENG_DEBUG(ENG_DEBUG, "Deffered Outgoing Call Handle = %d", outgoing_call_handle);
 872                                         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_OUTGOING, outgoing_call_handle, 0, NULL);
 873                                 }
 874
 875                                 if (pcall_agent->callagent_state == CALL_VC_CA_STATE_WAIT_HOLD)
 876                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 877                                 return TRUE;
 878                         }
 879                         break;
 880                 case VC_INOUT_STATE_INCOME_WAIT_HOLD:
 881                         {
 882                                 int error_code;
 883
 884                                 /*Change the Group State*/
 885                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_HOLD);
 886                                 CALL_ENG_DEBUG(ENG_DEBUG, "Gropu Index: %d , set to GROUP_STATE_HOLD", index);
 887
 888                                 if (_vc_core_tapi_rqst_answer_call(pcall_agent, VC_ANSWER_NORMAL, &error_code)) {
 889                                         CALL_ENG_DEBUG(ENG_DEBUG, "Voicecall Answered");
 890                                         /*TODO: Inform client to update ui */
 891                                 }
 892                                 if (pcall_agent->callagent_state == CALL_VC_CA_STATE_WAIT_HOLD) {
 893                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 894                                 }
 895                         }
 896                         break;
 897                 case VC_INOUT_STATE_INCOME_WAIT_HOLD_CONNECTED:
 898                         {
 899                                 CALL_ENG_DEBUG(ENG_DEBUG, "Hold arrived for Hold and Accept Event, Current IO State:%d", pcall_agent->io_state);
 900                                 /*Change state to wait_connected */
 901                                 _vc_core_ca_change_inout_state(pcall_agent, VC_INOUT_STATE_INCOME_WAIT_CONNECTED);
 902                         }
 903                         break;
 904                 case VC_INOUT_STATE_NONE:
 905                 default:        /*Fall Through */
 906                         CALL_ENG_DEBUG(ENG_DEBUG, "Not allowed io_state=%d", pcall_agent->io_state);
 907                         break;
 908                 }
 909
 910                 switch (pcall_agent->callagent_state) {
 911 #ifdef SWAP_SUPPORT
 912                 case CALL_VC_CA_STATE_WAIT_SWAP_HOLD_OR_ACTIVATE:
 913                         {
 914                                 int held_call_num = 0;
 915                                 int act_call_num = 0;
 916
 917                                 held_call_num = _vc_core_cm_get_held_call_count(&pcall_agent->call_manager);
 918                                 act_call_num = _vc_core_cm_get_active_call_count(&pcall_agent->call_manager);
 919                                 if ((held_call_num > 0 && act_call_num <= 0) || (act_call_num > 0 && held_call_num <= 0)) {
 920                                         if (CALL_VC_GROUP_STATE_HOLD != grp_state) {
 921                                                 /* Set the State to HOLD and inform client */
 922                                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_HOLD);
 923                                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_HELD, 0, 0, NULL);
 924                                         }
 925                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 926                                 } else {
 927                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_SWAP);
 928                                 }
 929                         }
 930                         break;
 931 #endif
 932                 case CALL_VC_CA_STATE_WAIT_SWAP:
 933                         {
 934                                 /*Always reset the agent state as the event for this wait state is arrived */
 935                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 936
 937                                 /*Swap the state only if the group state of the given call handle is not in hold state already
 938                                    as this is a hold confirmation event */
 939                                 if (CALL_VC_GROUP_STATE_HOLD != grp_state) {
 940                                         _vc_core_cm_swap_group_state(&pcall_agent->call_manager);
 941                                         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_SWAP, call_handle, 0, NULL);
 942                                 }
 943                         }
 944                         break;
 945                 case CALL_VC_CA_STATE_WAIT_HOLD:
 946                         {
 947                                 /* Change the Group State */
 948                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_HOLD);
 949                                 CALL_ENG_DEBUG(ENG_DEBUG, "Group Index: %d , set to GROUP_STATE_HOLD", index);
 950
 951                                 /* Change Call Agent State */
 952                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
 953
 954                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_HELD, call_handle, 0, NULL);
 955                         }
 956                         break;
 957                 case CALL_VC_CA_STATE_SS_WAIT_RELEASE_ALL_ACTIVECALL:
 958                         {
 959                                 gboolean active_call = _vc_core_cm_isexists_active_call(&pcall_agent->call_manager);
 960                                 gboolean held_call = _vc_core_cm_isexists_held_call(&pcall_agent->call_manager);
 961
 962                                 /*Upon waiting for  the success event for hold request,
 963                                    Other calls might have been released during this time, so the held call need to retrieved */
 964                                 if ((active_call == FALSE) && (held_call == TRUE)) {
 965                                         CALL_ENG_DEBUG(ENG_DEBUG, "Unhold call");
 966                                         if (_vc_core_tapi_rqst_retrieve_call(pcall_agent) == TRUE) {
 967                                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_UNHOLD);
 968                                         }
 969                                 }
 970                         }
 971                         break;
 972                 case CALL_VC_CA_STATE_NORMAL:
 973                 default:        /*Fall Through */
 974                         CALL_ENG_DEBUG(ENG_DEBUG, "Not allowed callagent_state=%d", pcall_agent->callagent_state);
 975                         return FALSE;
 976                         break;
 977                 }
 978         }
 979
 980         return TRUE;
 981 }
 982
 983 /**
 984 * This function handles TAPI call activate/retrieve event
 985 *
 986 * @return               Returns TRUE on success and FALSE on failure
 987 * @param[in]            pcall_agent             Pointer to the call agent state
 988 * @param[in]            call_handle             call handle associated with the call being retrieved
 989 * @param[in]            status                  TAPI cause in case of retrieve failed
 990 */
 991 gboolean _vc_core_tapi_event_handle_call_retrieve_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallCause_t status)
 992 {
 993         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
 994
 995         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, status = %d", call_handle, status);
 996
 997         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
 998                 CALL_ENG_DEBUG(ENG_DEBUG, "INVALID_CALLHANDLE Error");
 999                 return FALSE;
1000         }
1001
1002         if (TAPI_CAUSE_SUCCESS != status) {
1003                 switch (pcall_agent->callagent_state) {
1004 #ifdef SWAP_SUPPORT
1005                 case CALL_VC_CA_STATE_WAIT_SWAP_HOLD_OR_ACTIVATE:
1006                         {
1007                                 /*Reset the Agent State*/
1008                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1009                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SWAP_FAILED, 0, NULL);
1010                         }
1011                         break;
1012 #endif
1013                 case CALL_VC_CA_STATE_WAIT_SWAP:
1014                         {
1015                                 /*Reset the Call Agent State*/
1016                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1017                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SWAP_FAILED, 0, NULL);
1018                         }
1019                         break;
1020                 case CALL_VC_CA_STATE_WAIT_UNHOLD:
1021                         {
1022                                 /*Reset the Agent State*/
1023                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1024                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_RETREIVE_FAILED, 0, NULL);
1025                         }
1026                         break;
1027                 default:
1028                         CALL_ENG_DEBUG(ENG_DEBUG, "Not allowed callagent_state=%d", pcall_agent->callagent_state);
1029                         return FALSE;
1030                         break;
1031                 }
1032
1033         } else {
1034                 int index;
1035                 int cur_grp_state = 0;
1036
1037                 /*Get the Group Index and current group status */
1038                 index = _vc_core_cm_get_group_index(&pcall_agent->call_manager, call_handle);
1039                 cur_grp_state = _vc_core_cm_get_group_state(&pcall_agent->call_manager, index);
1040
1041                 CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, GP_Index:%d, Cur Gp State: %d", call_handle, index, cur_grp_state);
1042
1043                 switch (pcall_agent->callagent_state) {
1044 #ifdef SWAP_SUPPORT
1045                 case CALL_VC_CA_STATE_WAIT_SWAP_HOLD_OR_ACTIVATE:
1046                         {
1047                                 int held_call_num = 0;
1048                                 int act_call_num = 0;
1049
1050                                 held_call_num = _vc_core_cm_get_held_call_count(&pcall_agent->call_manager);
1051                                 act_call_num = _vc_core_cm_get_active_call_count(&pcall_agent->call_manager);
1052                                 if ((held_call_num > 0 && act_call_num <= 0) || (act_call_num > 0 && held_call_num <= 0)) {
1053                                         if (CALL_VC_GROUP_STATE_ACTIVE != cur_grp_state) {
1054                                                 /* Set  the State ACTIVE and inform client */
1055                                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_ACTIVE);
1056                                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_RETREIVED, 0, 0, NULL);
1057                                         }
1058                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1059                                 } else {
1060                                         _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_WAIT_SWAP);
1061                                 }
1062                         }
1063                         break;
1064 #endif
1065                 case CALL_VC_CA_STATE_WAIT_SWAP:
1066                         {
1067                                 /* Always reset the agent state as the event for the wait state is arrived */
1068                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1069
1070                                 /*Change the state only when the current state of the given handle is not in ACTIVE state */
1071                                 if (CALL_VC_GROUP_STATE_ACTIVE != cur_grp_state) {
1072                                         _vc_core_cm_swap_group_state(&pcall_agent->call_manager);
1073                                         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_SWAP, call_handle, 0, NULL);
1074                                 }
1075                         }
1076                         break;
1077                 case CALL_VC_CA_STATE_WAIT_UNHOLD:
1078                         {
1079                                 int index;
1080                                 /* get the member info and chage info */
1081                                 index = _vc_core_cm_get_group_index(&pcall_agent->call_manager, call_handle);
1082                                 _vc_core_cm_set_group_state(&pcall_agent->call_manager, index, CALL_VC_GROUP_STATE_ACTIVE);
1083
1084                                 _vc_core_ca_change_agent_state(pcall_agent, CALL_VC_CA_STATE_NORMAL);
1085
1086                                 /*Send Call Retreived Event to Client*/
1087                                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_RETREIVED, call_handle, 0, NULL);
1088                         }
1089                         break;
1090                 default:
1091                         CALL_ENG_DEBUG(ENG_DEBUG, "Not allowed callagent_state=%d", pcall_agent->callagent_state);
1092                         /*return FALSE if the event is not handled here, because end call memeber will be unnecessarily cleared if returned TRUE */
1093                         return FALSE;
1094                         break;
1095                 }
1096
1097         }
1098
1099         return TRUE;
1100 }
1101
1102 /**
1103  * This function handles call join/conference event
1104  *
1105  * @return              Returns TRUE on success and FALSE on failure
1106  * @param[in]           pcall_agent             Pointer to the call agent state
1107  * @param[in]           call_handle             call handle assoicated with the call being joined
1108  * @param[in]           status                  tapi cause incase of join failed
1109  */
1110 gboolean _vc_core_tapi_event_handle_call_join_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallCause_t status)
1111 {
1112         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1113
1114         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, status = %d", call_handle, status);
1115
1116         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
1117                 CALL_ENG_DEBUG(ENG_DEBUG, "INVALID_CALLHANDLE Error");
1118                 return FALSE;
1119         }
1120
1121         if (TAPI_CAUSE_SUCCESS != status) {
1122                 CALL_ENG_DEBUG(ENG_DEBUG, "Join fail and return..");
1123                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SETUP_CONF_FAILED, 0, NULL);
1124                 return TRUE;
1125         }
1126
1127         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
1128
1129         /* get the member info and chage info */
1130         _vc_core_cm_join_group(&pcall_agent->call_manager);
1131
1132         CALL_VC_DUMP_CALLDETAILS(&pcall_agent->call_manager);
1133
1134         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_SETUP_CONF, 0, 0, NULL);
1135         return TRUE;
1136 }
1137
1138 /**
1139  * This function handles call split/private call event
1140  *
1141  * @return              Returns TRUE on success and FALSE on failure
1142  * @param[in]           pcall_agent             Pointer to the call agent state
1143  * @param[in]           call_handle             call handle associated with the call being made as private call
1144  * @param[in]           status                  TAPI cause in case of split failed
1145  */
1146 gboolean _vc_core_tapi_event_handle_call_split_event(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallCause_t status)
1147 {
1148         call_vc_call_objectinfo_t callobject_info;
1149
1150         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1151
1152         CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, status = %d", call_handle, status);
1153
1154         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
1155                 CALL_ENG_DEBUG(ENG_DEBUG, "INVALID_CALLHANDLE Error");
1156                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SPLIT_CONF_FAILED, 0, NULL);
1157                 return FALSE;
1158         }
1159
1160         if (TAPI_CAUSE_SUCCESS != status) {
1161                 CALL_ENG_DEBUG(ENG_DEBUG, "Split fail and return..");
1162                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, ERROR_VOICECALL_SPLIT_CONF_FAILED, 0, NULL);
1163                 return FALSE;
1164         }
1165
1166         /* get the member info and chage info */
1167         _vc_core_cm_clear_call_object(&callobject_info);
1168         _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
1169
1170         _vc_core_cm_split_group(&pcall_agent->call_manager, call_handle);
1171
1172         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_SPLIT_CONF, call_handle, 0, NULL);     /* Added Call handle */
1173         return TRUE;
1174 }
1175
1176 /**
1177 * This function handles the call transfer event
1178 *
1179 * @return               Returns TRUE on success and FALSE on failure
1180 * @param[in]            pcall_agent             Pointer to the call agent state
1181 * @param[in]            status                  TAPI cause in case of hold failed
1182 */
1183 gboolean _vc_core_tapi_event_handle_call_transfer_event(call_vc_callagent_state_t *pcall_agent, TelCallCause_t status)
1184 {
1185         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1186
1187         CALL_ENG_DEBUG(ENG_DEBUG, "Started, status = %d", status);
1188
1189         if (TAPI_CAUSE_SUCCESS != status) {
1190                 int err_cause = 0;
1191                 CALL_ENG_DEBUG(ENG_DEBUG, "TapiTransfer Failed");
1192                 if (VC_TAPI_INVALID_CALLHANDLE == _vc_core_cm_get_incoming_call_handle(&pcall_agent->call_manager)
1193                     && VC_TAPI_INVALID_CALLHANDLE == _vc_core_cm_get_outgoing_call_handle(&pcall_agent->call_manager)) {
1194                         err_cause = ERROR_VOICECALL_TRANSFER_FAILED;
1195
1196                 } else {
1197                         if (_vc_core_cm_isexists_incoming_call(&pcall_agent->call_manager)) {
1198                                 err_cause = ERROR_VOICECALL_TRANSFER_FAILED;
1199                         } else if (VC_INOUT_STATE_OUTGOING_WAIT_CONNECTED == pcall_agent->io_state) {
1200                                 err_cause = ERROR_VOICECALL_TRANSFER_FAILED;
1201                         }
1202                 }
1203
1204                 _vc_core_ca_send_event_to_client(pcall_agent, VC_ERROR_OCCURED, err_cause, 0, NULL);
1205                 CALL_ENG_DEBUG(ENG_DEBUG, "Transfer failed and return..");
1206
1207                 return TRUE;
1208         } else {
1209                 CALL_ENG_DEBUG(ENG_DEBUG, "Transfer success!");
1210                 _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_TRANSFERRED, 0, 0, NULL);
1211         }
1212         /*todo ss: Check Updating flag gbpsh_voicecall_command_transfer*/
1213         return TRUE;
1214 }
1215
1216 /**
1217 * This function handles the TAPI connected line indication handle
1218 *
1219 * @return               Returns TRUE on success and FALSE on failure
1220 * @param[in]            pcall_agent                             Pointer to the call agent state
1221 * @param[in]            call_handle                             TAPI Call Handle associated with connected line indication
1222 * @param[in]            connected_number_info   Connected Number Details
1223 */
1224 gboolean _vc_core_tapi_event_connected_line_ind_handle(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallConnectedNumberInfo_t *connected_number_info)
1225 {
1226         call_vc_call_objectinfo_t callobject_info;
1227         call_vc_handle active_call_handle = VC_TAPI_INVALID_CALLHANDLE;
1228         gboolean bConnectedCall = FALSE;
1229
1230         CALL_ENG_DEBUG(ENG_DEBUG, ":Number(%s)", connected_number_info->number);
1231
1232         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1233
1234         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
1235                 CALL_ENG_DEBUG(ENG_ERR, " INVALID_CALLHANDLE Error");
1236                 return FALSE;
1237         }
1238
1239         _vc_core_cm_clear_call_object(&callobject_info);
1240
1241         if (_vc_core_cm_get_outgoing_call_info(&pcall_agent->call_manager, &callobject_info)) {
1242                 if (callobject_info.call_handle != call_handle) {
1243                         CALL_ENG_DEBUG(ENG_ERR, "It is not outging call(Call Handle = %d, MO Call Handle =%d)", call_handle, callobject_info.call_handle);
1244                         return FALSE;
1245                 }
1246         } else {
1247                 if (_vc_core_cm_get_first_active_call_handle(&pcall_agent->call_manager, &active_call_handle) == -1) {
1248                         CALL_ENG_DEBUG(ENG_ERR, "No Active Calls(Call Handle = %d)", call_handle);
1249                         return FALSE;
1250                 }
1251
1252                 if (active_call_handle != call_handle) {
1253                         CALL_ENG_DEBUG(ENG_ERR, "Call Handle Mismatch(Call Handle = %d)", call_handle);
1254                         return FALSE;
1255                 }
1256
1257                 _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info);
1258                 bConnectedCall = TRUE;
1259         }
1260
1261         switch (connected_number_info->name_mode) {
1262         case TAPI_CALL_NAME_AVAIL:      /*if sznumber of the callInfo is null, set Anoymous*/
1263
1264                 if (0 == strlen(connected_number_info->number)) {
1265                         /*Forwarded Call number is unknown*/
1266                         memset(callobject_info.connected_telnumber, 0, sizeof(callobject_info.connected_telnumber));
1267                 } else {
1268                         _vc_core_util_strcpy(callobject_info.connected_telnumber, sizeof(callobject_info.connected_telnumber), connected_number_info->number);
1269                 }
1270
1271                 break;
1272
1273         case TAPI_CALL_NAME_RESTRICTED:
1274         case TAPI_CALL_NAME_AVAIL_RESTRICTED:   /*withheld*/
1275                 /*Forwarded Call number is unknown*/
1276                 memset(callobject_info.connected_telnumber, 0, sizeof(callobject_info.connected_telnumber));
1277                 break;
1278
1279         case TAPI_CALL_NAME_UNAVAIL:    /*Anoymous*/
1280         default:
1281                 /*Forwarded Call number is unknown*/
1282                 memset(callobject_info.connected_telnumber, 0, sizeof(callobject_info.connected_telnumber));
1283                 break;
1284         }
1285
1286         /*Set the modified call object to call manager*/
1287         _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
1288
1289         /*Send Event to the Client*/
1290         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_SS_CONNECT_LINE_IND, callobject_info.call_handle, 0, (void *)callobject_info.connected_telnumber);
1291
1292         return TRUE;
1293 }
1294
1295 /**
1296  * This function handles the AOC Event
1297  *
1298  * @return              Returns TRUE on success and FALSE on failure
1299  * @param[in]           pcall_agent             Pointer to the call agent state
1300  * @param[in]           call_handle             Call Handle
1301  * @param[in]           ptapi_aoc_info  AOC info associated with the AOC Event
1302  */
1303 gboolean _vc_core_tapi_event_handle_aoc(call_vc_callagent_state_t *pcall_agent, call_vc_handle call_handle, TelCallAocInfo_t *ptapi_aoc_info)
1304 {
1305         call_vc_call_objectinfo_t callobject_info;
1306
1307         VOICECALL_RETURN_FALSE_IF_FAIL(pcall_agent != NULL);
1308
1309         CALL_ENG_DEBUG(ENG_DEBUG, "Started, Call Handle = %d", call_handle);
1310         if (call_handle == VC_TAPI_INVALID_CALLHANDLE) {
1311                 CALL_ENG_DEBUG(ENG_ERR, "INVALID_CALLHANDLE Error");
1312                 return FALSE;
1313         }
1314
1315         /* get the member info and chage info */
1316         _vc_core_cm_clear_call_object(&callobject_info);
1317         if (FALSE == _vc_core_cm_get_call_object(&pcall_agent->call_manager, call_handle, &callobject_info)) {
1318                 CALL_ENG_DEBUG(ENG_ERR, "Call Object Not available");
1319                 return FALSE;
1320         }
1321
1322         /* Store the call cost TAPI info */
1323         callobject_info.aoc_ccm = ptapi_aoc_info->CCM;
1324         memcpy((void *)callobject_info.aoc_currency, (const void *)ptapi_aoc_info->szCurrency, VC_AOC_CURRENCY_CODE_LEN_MAX);
1325
1326         /* Set the modified call object to the Call Mangaer */
1327         _vc_core_cm_set_call_object(&pcall_agent->call_manager, &callobject_info);
1328
1329         _vc_core_ca_send_event_to_client(pcall_agent, VC_CALL_IND_AOC, call_handle, 0, &callobject_info);
1330         return TRUE;
1331
1332 }
1333
1334 static gboolean __call_vc_get_aoc_ppm_value_idle_cb(gpointer pdata)
1335 {
1336         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pdata;
1337         __call_vc_get_aoc_ppm_value(pcall_agent);
1338         return FALSE;
1339 }
1340
1341 static gboolean __call_vc_download_call_timer_cb(gpointer pdata)
1342 {
1343         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pdata;
1344         _vc_core_ca_end_all_calls(pcall_agent);
1345         return FALSE;
1346 }
1347
1348 static void __call_vc_get_aoc_ppm_value(call_vc_callagent_state_t *pcall_agent)
1349 {
1350         TapiResult_t tapi_error = TAPI_API_SUCCESS;
1351
1352         CALL_ENG_DEBUG(ENG_DEBUG, "..");
1353
1354         if (pcall_agent->aoc_ppm == VC_INVALID_PPM) {
1355                 tapi_error = tel_get_ss_aoc_info(pcall_agent->tapi_handle, TAPI_SS_AOC_TYPE_PUC, _vc_core_engine_get_aoc_info_cb, NULL);
1356
1357                 if (tapi_error != TAPI_API_SUCCESS) {
1358                         CALL_ENG_DEBUG(ENG_ERR, "TAPI Error: %x", tapi_error);
1359                 }
1360         }
1361 }