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