call-engine/voice-call-engine.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 "voice-call-engine.h"
  19 #include "vc-core-util.h"
  20 #include "voice-call-core.h"
  21 #include "vc-core-engine-types.h"
  22 #include "voice-call-service.h"
  23 #include "voice-call-dbus.h"
  24
  25 typedef struct {
  26         void *puser_data;
  27         vcall_engine_app_cb cb_func;
  28 } app_cb_t;
  29
  30 call_vc_core_state_t *global_pcall_core = NULL;
  31
  32 static app_cb_t *app_client_data = NULL;
  33
  34 /**
  35  * This function send events to client.
  36  *
  37  * @return      int     API Result Code.
  38  * @param[in]
  39 */
  40 gboolean vcall_engine_send_event_to_client(int event, void *pdata)
  41 {
  42         CALL_ENG_DEBUG(ENG_DEBUG, "..\n");
  43         if (app_client_data->cb_func != NULL) {
  44                 CALL_ENG_DEBUG(ENG_DEBUG, "Sending Event to APP Client\n");
  45                 app_client_data->cb_func(event, pdata, app_client_data->puser_data);
  46         }
  47         CALL_ENG_DEBUG(ENG_ERR, "End..\n");
  48         return TRUE;
  49 }
  50
  51 /**
  52  * This function initialize voice call engine.
  53  *
  54  * @return      int     API Result Code.
  55  * @param[in]
  56 */
  57 int vcall_engine_init(vcall_engine_app_cb pcb_func, void *puser_data)
  58 {
  59         CALL_ENG_DEBUG(ENG_WARN, "..\n");
  60
  61         /* thread system initialization */
  62         if (!g_thread_supported()) {
  63                 CALL_ENG_KPI("g_thread_init start");
  64                 g_thread_init(NULL);
  65                 CALL_ENG_KPI("g_thread_init done");
  66         }
  67
  68         global_pcall_core = (call_vc_core_state_t *)calloc(1, sizeof(call_vc_core_state_t));
  69         if (global_pcall_core == NULL) {
  70                 CALL_ENG_DEBUG(ENG_ERR, "Memory Allocation Failed\n");
  71                 return VCALL_ENGINE_API_FAILED;
  72         }
  73         CALL_ENG_DEBUG(ENG_DEBUG, "global_pcall_core alloctated memory:[%d],global_pcall_core(0x%x) \n", sizeof(call_vc_core_state_t), global_pcall_core);
  74
  75         if (FALSE == voicecall_core_init(global_pcall_core)) {
  76                 CALL_ENG_DEBUG(ENG_DEBUG, "voicecall_core_init() failed");
  77                 return VCALL_ENGINE_API_FAILED;
  78         }
  79
  80         app_client_data = (app_cb_t *) calloc(1, sizeof(app_cb_t));
  81         if (app_client_data == NULL) {
  82                 CALL_ENG_DEBUG(ENG_ERR, "Memory Allocation Failed\n");
  83                 return VCALL_ENGINE_API_FAILED;
  84         }
  85         app_client_data->cb_func = pcb_func;
  86         app_client_data->puser_data = puser_data;
  87
  88         CALL_ENG_DEBUG(ENG_DEBUG, "Init dbus connection\n");
  89         vc_engine_dbus_receiver_setup();
  90         return VCALL_ENGINE_API_SUCCESS;
  91
  92 }
  93
  94 /**
  95  * This function processes mo nomal call.
  96  *
  97  * @return      int     API Result Code.
  98  * @param[in]
  99 */
 100 int vcall_engine_process_normal_call(char *number, int ct_index, gboolean b_download_call)
 101 {
 102         CALL_ENG_DEBUG(ENG_DEBUG, " number is (%s)\n", number);
 103         voicecall_engine_t *pcall_engine = global_pcall_core->pcall_engine;
 104         vc_engine_outgoing_type event_data;
 105         char number_after_removal[VC_PHONE_NUMBER_LENGTH_MAX] = {"\0",};
 106         int io_state;
 107
 108         if (number == NULL || pcall_engine == NULL)
 109                 return VCALL_ENGINE_API_FAILED;
 110
 111         _vc_core_engine_status_set_download_call(pcall_engine, b_download_call);
 112
 113         /* check the call-engine state before proceeding with call processing */
 114         _vc_core_engine_status_get_engine_iostate(pcall_engine, &io_state);
 115         if (io_state != VC_INOUT_STATE_NONE) {
 116                 CALL_ENG_DEBUG(ENG_DEBUG, "IO State [%d] not NONE, cannot proceed with the call \n", io_state);
 117                 voicecall_core_set_status(global_pcall_core, CALL_VC_CORE_FLAG_SETUPCALL_FAIL, TRUE);
 118                 vc_engine_msg_box_type mbox_event_data;
 119
 120                 memset(&mbox_event_data, 0, sizeof(mbox_event_data));
 121                 mbox_event_data.string_id = IDS_CALL_POP_CALLNOTCALLOWED;
 122                 vcall_engine_send_event_to_client(VC_ENGINE_MSG_MESSAGE_BOX_TO_UI, (void *)&mbox_event_data);
 123                 return VCALL_ENGINE_API_FAILED;
 124         }
 125
 126         memset(&(global_pcall_core->call_setup_info), 0, sizeof(global_pcall_core->call_setup_info));
 127         global_pcall_core->call_setup_info.call_setup_by = VC_CALL_SETUP_BY_NORMAL;
 128         global_pcall_core->call_setup_info.call_type = VC_CALL_ORIG_TYPE_NORMAL;
 129
 130         memset(&event_data, 0, sizeof(event_data));
 131
 132         _vc_core_util_remove_invalid_chars(number, number_after_removal);
 133         snprintf(global_pcall_core->call_setup_info.source_tel_number, VC_PHONE_NUMBER_LENGTH_MAX, number_after_removal);
 134         voicecall_core_extract_phone_number(number_after_removal, event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 135
 136         if (strlen(event_data.call_num) > VC_PHONE_NUMBER_LENGTH_MAX) {
 137                 CALL_ENG_DEBUG(ENG_ERR, " WARNING!! number is larger than max num length!! \n");
 138                 memcpy(global_pcall_core->call_setup_info.tel_number, event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 139         } else {
 140                 memcpy(global_pcall_core->call_setup_info.tel_number, event_data.call_num, strlen(event_data.call_num));
 141         }
 142         CALL_ENG_DEBUG(ENG_DEBUG, "number:[%s]", number);
 143         CALL_ENG_DEBUG(ENG_DEBUG, "number_after_removal:[%s]", number_after_removal);
 144         CALL_ENG_DEBUG(ENG_DEBUG, "global_pcall_core->call_setup_info.source_tel_number:[%s]", global_pcall_core->call_setup_info.source_tel_number);
 145         CALL_ENG_DEBUG(ENG_DEBUG, "global_pcall_core->call_setup_info.tel_number:[%s]", global_pcall_core->call_setup_info.tel_number);
 146         CALL_ENG_DEBUG(ENG_DEBUG, "event_data.call_num:[%s]", event_data.call_num);
 147
 148         vcall_engine_send_event_to_client(VC_ENGINE_MSG_OUTGOING_TO_UI, (void *)&event_data);
 149
 150         if (voicecall_core_setup_call(global_pcall_core, FALSE)) {
 151                 CALL_ENG_DEBUG(ENG_DEBUG, " success!! \n");
 152         } else {
 153                 CALL_ENG_DEBUG(ENG_DEBUG, " failed!! \n");
 154         }
 155         return VCALL_ENGINE_API_SUCCESS;
 156
 157 }
 158
 159 /**
 160  * This function processes mo emergency call.
 161  *
 162  * @return      int     API Result Code.
 163  * @param[in]
 164 */
 165 int vcall_engine_process_emergency_call(char *number)
 166 {
 167         CALL_ENG_DEBUG(ENG_DEBUG, " number is : [%s] \n", number);
 168         voicecall_engine_t *pcall_engine = global_pcall_core->pcall_engine;
 169         gboolean bDefaultNumber = FALSE;
 170         vc_engine_outgoing_type event_data;
 171         int io_state;
 172
 173         /* check the call-engine state before proceeding with emergency call processing */
 174         _vc_core_engine_status_get_engine_iostate(pcall_engine, &io_state);
 175         if (io_state != VC_INOUT_STATE_NONE) {
 176                 CALL_ENG_DEBUG(ENG_DEBUG, "IO State [%d] not NONE, cannot proceed with the call \n", io_state);
 177                 voicecall_core_set_status(global_pcall_core, CALL_VC_CORE_FLAG_SETUPCALL_FAIL, TRUE);
 178                 vc_engine_msg_box_type mbox_event_data;
 179
 180                 memset(&mbox_event_data, 0, sizeof(mbox_event_data));
 181                 mbox_event_data.string_id = IDS_CALL_POP_CALLNOTCALLOWED;
 182                 vcall_engine_send_event_to_client(VC_ENGINE_MSG_MESSAGE_BOX_TO_UI, (void *)&mbox_event_data);
 183                 return VCALL_ENGINE_API_FAILED;
 184         }
 185
 186         memset(&event_data, 0, sizeof(event_data));
 187
 188         memset(&(global_pcall_core->call_setup_info), 0, sizeof(global_pcall_core->call_setup_info));
 189
 190         bDefaultNumber = strlen(number) ? FALSE : TRUE;
 191         if (bDefaultNumber == TRUE) {
 192                 global_pcall_core->call_setup_info.call_setup_by = VC_CALL_SETUP_BY_NORMAL;
 193                 global_pcall_core->call_setup_info.call_type = VC_CALL_ORIG_TYPE_EMERGENCY;
 194                 if (strlen("911") < sizeof(event_data.call_num))
 195                         _vc_core_util_strcpy(event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX, "911");
 196
 197                 memcpy(global_pcall_core->call_setup_info.tel_number, "911", strlen("911"));
 198         } else {
 199                 global_pcall_core->call_setup_info.call_setup_by = VC_CALL_SETUP_BY_NORMAL;
 200                 global_pcall_core->call_setup_info.call_type = VC_CALL_ORIG_TYPE_PINLOCK;
 201                 voicecall_core_extract_phone_number(number, event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 202                 if (strlen(number) > VC_PHONE_NUMBER_LENGTH_MAX) {
 203                         CALL_ENG_DEBUG(ENG_ERR, " WARNING!! number is larger than max num length!! \n");
 204                         memcpy(global_pcall_core->call_setup_info.source_tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 205                         memcpy(global_pcall_core->call_setup_info.tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 206                 } else {
 207                         memcpy(global_pcall_core->call_setup_info.source_tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 208                         memcpy(global_pcall_core->call_setup_info.tel_number, number, strlen(number));
 209                 }
 210         }
 211
 212         event_data.contact_index = -1;
 213         event_data.phone_type = -1;
 214
 215         vcall_engine_send_event_to_client(VC_ENGINE_MSG_OUTGOING_TO_UI, (void *)&event_data);
 216
 217         if (voicecall_core_setup_call(global_pcall_core, TRUE)) {
 218                 CALL_ENG_DEBUG(ENG_DEBUG, " success!! \n");
 219         } else {
 220                 CALL_ENG_DEBUG(ENG_DEBUG, " failed!! \n");
 221         }
 222         return VCALL_ENGINE_API_SUCCESS;
 223 }
 224
 225 int vcall_engine_process_emergency_call_test(char *number)
 226 {
 227         CALL_ENG_DEBUG(ENG_DEBUG, " number is : [%s] \n", number);
 228         voicecall_engine_t *pcall_engine = global_pcall_core->pcall_engine;
 229         gboolean bDefaultNumber = FALSE;
 230         vc_engine_outgoing_type event_data;
 231         int io_state;
 232
 233         /* check the call-engine state before proceeding with emergency call processing */
 234         _vc_core_engine_status_get_engine_iostate(pcall_engine, &io_state);
 235         if (io_state != VC_INOUT_STATE_NONE) {
 236                 CALL_ENG_DEBUG(ENG_DEBUG, "IO State [%d] not NONE, cannot proceed with the call \n", io_state);
 237                 voicecall_core_set_status(global_pcall_core, CALL_VC_CORE_FLAG_SETUPCALL_FAIL, TRUE);
 238                 vc_engine_msg_box_type mbox_event_data;
 239
 240                 memset(&mbox_event_data, 0, sizeof(mbox_event_data));
 241                 mbox_event_data.string_id = IDS_CALL_POP_CALLNOTCALLOWED;
 242                 vcall_engine_send_event_to_client(VC_ENGINE_MSG_MESSAGE_BOX_TO_UI, (void *)&mbox_event_data);
 243                 return VCALL_ENGINE_API_FAILED;
 244         }
 245
 246         memset(&event_data, 0, sizeof(event_data));
 247
 248         memset(&(global_pcall_core->call_setup_info), 0, sizeof(global_pcall_core->call_setup_info));
 249
 250         bDefaultNumber = strlen(number) ? FALSE : TRUE;
 251         if (bDefaultNumber == TRUE) {
 252                 global_pcall_core->call_setup_info.call_setup_by = VC_CALL_SETUP_BY_NORMAL;
 253                 global_pcall_core->call_setup_info.call_type = VC_CALL_ORIG_TYPE_EMERGENCY;
 254                 if (strlen("911") < sizeof(event_data.call_num))
 255                         _vc_core_util_strcpy(event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX, "911");
 256
 257                 memcpy(global_pcall_core->call_setup_info.tel_number, "911", strlen("911"));
 258         } else {
 259                 global_pcall_core->call_setup_info.call_setup_by = VC_CALL_SETUP_BY_NORMAL;
 260                 global_pcall_core->call_setup_info.call_type = VC_CALL_ORIG_TYPE_PINLOCK;
 261                 voicecall_core_extract_phone_number(number, event_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 262                 if (strlen(number) > VC_PHONE_NUMBER_LENGTH_MAX) {
 263                         CALL_ENG_DEBUG(ENG_ERR, " WARNING!! number is larger than max num length!! \n");
 264                         memcpy(global_pcall_core->call_setup_info.source_tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 265                         memcpy(global_pcall_core->call_setup_info.tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 266                 } else {
 267                         memcpy(global_pcall_core->call_setup_info.source_tel_number, number, VC_PHONE_NUMBER_LENGTH_MAX);
 268                         memcpy(global_pcall_core->call_setup_info.tel_number, number, strlen(number));
 269                 }
 270         }
 271
 272         event_data.contact_index = -1;
 273         event_data.phone_type = -1;
 274
 275         vcall_engine_send_event_to_client(VC_ENGINE_MSG_OUTGOING_TO_UI, (void *)&event_data);
 276
 277         {
 278                 int call_handle = 1;
 279                 vc_engine_outgoing_orig_type orig_event_data;
 280                 call_vc_call_objectinfo_t callobject_info;
 281
 282                 memset(&orig_event_data, 0, sizeof(orig_event_data));
 283                 orig_event_data.call_handle = call_handle;
 284                 orig_event_data.bemergency = TRUE;
 285
 286                 CALL_ENG_DEBUG(ENG_DEBUG, "Call Handle = %d, bemergency:[%d] \n", orig_event_data.call_handle, orig_event_data.bemergency);
 287                 vcall_engine_send_event_to_client(VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI_TEST, (void *)&orig_event_data);
 288         }
 289
 290         return VCALL_ENGINE_API_SUCCESS;
 291 }
 292
 293 /**
 294  * This function processes sat setup call.
 295  *
 296  * @return      int     API Result Code.
 297  * @param[in]
 298 */
 299 int vcall_engine_process_sat_setup_call(vcall_engine_sat_setup_call_info_t *sat_setup_call_info)
 300 {
 301         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 302         voicecall_core_process_sat_setup_call(sat_setup_call_info);
 303         return VCALL_ENGINE_API_SUCCESS;
 304 }
 305
 306 /**
 307  * This function processes incoming call.
 308  *
 309  * @return      int     API Result Code.
 310  * @param[in]
 311 */
 312 int vcall_engine_process_incoming_call(vcall_engine_incoming_info_t *incoming_call_info)
 313 {
 314         call_vc_core_incoming_info_t tmp_incom_info = { 0, };
 315
 316         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 317
 318         tmp_incom_info.call_handle = incoming_call_info->call_handle;
 319         tmp_incom_info.call_type = incoming_call_info->call_type;
 320         tmp_incom_info.cli_presentation_indicator = incoming_call_info->cli_presentation_indicator;
 321         _vc_core_util_strcpy(tmp_incom_info.call_num, sizeof(tmp_incom_info.call_num), incoming_call_info->call_num);
 322         tmp_incom_info.calling_name_mode = incoming_call_info->calling_name_mode;
 323         _vc_core_util_strcpy(tmp_incom_info.calling_name, sizeof(tmp_incom_info.calling_name), incoming_call_info->calling_name);
 324         _vc_core_util_strcpy(tmp_incom_info.redirected_number, sizeof(tmp_incom_info.redirected_number), incoming_call_info->redirected_number);
 325         _vc_core_util_strcpy(tmp_incom_info.redirected_sub_address, sizeof(tmp_incom_info.redirected_sub_address), incoming_call_info->redirected_sub_address);
 326         tmp_incom_info.cli_cause = incoming_call_info->cli_cause;
 327         tmp_incom_info.bfwded = incoming_call_info->bfwded;
 328         tmp_incom_info.active_line = incoming_call_info->active_line;
 329
 330         voicecall_core_process_incoming_call(&tmp_incom_info);
 331         return VCALL_ENGINE_API_SUCCESS;
 332 }
 333
 334 /**
 335  * This function answers an incoming call
 336  *
 337  * @return      int     API Result Code.
 338  * @param[in]           none
 339 */
 340 int vcall_engine_answer_call(void)
 341 {
 342         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 343         int ret = VCALL_ENGINE_API_FAILED;
 344
 345         ret = voicecall_core_answer_call(global_pcall_core, FALSE);
 346         CALL_ENG_DEBUG(ENG_DEBUG, " ret:[%d] \n", ret);
 347         return ret;
 348 }
 349
 350 /**
 351  * This function answers an incoming call  according to the given type
 352  *
 353  * @return      int     API Result Code.
 354  * @param[in]           answer_type             answer type
 355  */
 356 int vcall_engine_answer_call_by_type(vcall_engine_answer_type_t answer_type)
 357 {
 358         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 359         CALL_ENG_DEBUG(ENG_DEBUG, "answer_type:[%d]\n", answer_type);
 360
 361         if (TRUE == voicecall_core_answer_call_bytype(global_pcall_core, answer_type)) {
 362                 return VCALL_ENGINE_API_SUCCESS;
 363         } else {
 364                 return VCALL_ENGINE_API_FAILED;
 365         }
 366
 367 }
 368
 369 /**
 370  * This function cancel outgoing call
 371  *
 372  * @return      int     API Result Code.
 373  * @param[in]           none
 374  */
 375 int vcall_engine_cancel_call(void)
 376 {
 377         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 378
 379         if (TRUE == voicecall_core_cancel_call(global_pcall_core)) {
 380                 return VCALL_ENGINE_API_SUCCESS;
 381         } else {
 382                 return VCALL_ENGINE_API_FAILED;
 383         }
 384 }
 385
 386 /**
 387  * This function reject incoming call
 388  *
 389  * @return      int     API Result Code.
 390  * @param[in]           none
 391  */
 392 int vcall_engine_reject_call(void)
 393 {
 394         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 395
 396         if (TRUE == voicecall_core_reject_mt(global_pcall_core, TRUE)) {
 397                 return VCALL_ENGINE_API_SUCCESS;
 398         } else {
 399                 return VCALL_ENGINE_API_FAILED;
 400         }
 401 }
 402
 403 /**
 404  * This function release a active or held call
 405  *
 406  * @return      int     API Result Code.
 407  * @param[in]           none
 408  */
 409 int vcall_engine_release_call(void)
 410 {
 411         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 412
 413         if (TRUE == voicecall_core_end_call(global_pcall_core)) {
 414                 return VCALL_ENGINE_API_SUCCESS;
 415         } else {
 416                 return VCALL_ENGINE_API_FAILED;
 417         }
 418 }
 419
 420 /**
 421  * This function release a call by handle
 422  *
 423  * @return      int     API Result Code.
 424  * @param[in]   int     call_handle
 425  */
 426 int vcall_engine_release_call_by_handle(int call_handle)
 427 {
 428         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 429         CALL_ENG_DEBUG(ENG_DEBUG, "call_handle:[%d]\n", call_handle);
 430
 431         if (TRUE == voicecall_core_end_call_by_handle(global_pcall_core, call_handle)) {
 432                 return VCALL_ENGINE_API_SUCCESS;
 433         } else {
 434                 return VCALL_ENGINE_API_FAILED;
 435         }
 436 }
 437
 438 /**
 439  * This function release calls by type
 440  *
 441  * @return      int     API Result Code.
 442  * @param[in]           release_type release_type
 443  */
 444 int vcall_engine_release_call_by_type(vcall_engine_release_type_t release_type)
 445 {
 446         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 447         int ret = FALSE;
 448
 449         CALL_ENG_DEBUG(ENG_DEBUG, " release_type : [%d]\n", release_type);
 450         switch (release_type) {
 451         case VCALL_ENGINE_RELEASE_ALL_ACTIVE_CALLS:
 452                 {
 453                         ret = voicecall_core_end_all_active_calls(global_pcall_core);
 454                 }
 455                 break;
 456
 457         case VCALL_ENGINE_RELEASE_ALL_HELD_CALLS:
 458                 {
 459                         ret = voicecall_core_end_all_held_calls(global_pcall_core);
 460                 }
 461                 break;
 462
 463         case VCALL_ENGINE_RELEASE_ALL_CALLS:
 464                 {
 465                         ret = voicecall_core_end_all_calls(global_pcall_core);
 466                 }
 467                 break;
 468
 469         default:
 470                 CALL_ENG_DEBUG(ENG_DEBUG, " Unknown release_type : [%d]\n", release_type);
 471                 break;
 472
 473         }
 474
 475         if (ret == TRUE) {
 476                 return VCALL_ENGINE_API_SUCCESS;
 477         } else {
 478                 return VCALL_ENGINE_API_FAILED;
 479         }
 480 }
 481
 482 /**
 483  * This function processes hold/retrive/swap calls.
 484  *
 485  * @return      int     API Result Code.
 486  * @param[in]           none
 487  */
 488 int vcall_engine_process_hold_call(void)
 489 {
 490         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 491         int ret = FALSE;
 492
 493         ret = voicecall_core_process_hold_call(global_pcall_core);
 494         if (ret == TRUE) {
 495                 return VCALL_ENGINE_API_SUCCESS;
 496         } else {
 497                 return VCALL_ENGINE_API_FAILED;
 498         }
 499 }
 500
 501 /**
 502  * This function processes in call SS code..
 503  *
 504  * @return      int     API Result Code.
 505  * @param[in]           none
 506  */
 507 void vcall_engine_process_incall_ss(char *number)
 508 {
 509         CALL_ENG_DEBUG(ENG_WARN, "number(%s)\n");
 510
 511         voicecall_core_process_incall_ss(global_pcall_core, number);
 512 }
 513
 514 /**
 515  * This function sets up a conference calls
 516  *
 517  * @return      int     API Result Code.
 518  * @param[in]           none
 519  */
 520 int vcall_engine_join_call(void)
 521 {
 522         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 523         int ret = FALSE;
 524
 525         ret = voicecall_core_setup_conference(global_pcall_core);
 526         if (ret == TRUE) {
 527                 return VCALL_ENGINE_API_SUCCESS;
 528         } else {
 529                 return VCALL_ENGINE_API_FAILED;
 530         }
 531 }
 532
 533 /**
 534  * This function make a private call in conference calls.
 535  *
 536  * @return      int     API Result Code.
 537  * @param[in]   int     call_handle
 538  */
 539 int vcall_engine_split_call(int call_handle)
 540 {
 541         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 542         int ret = FALSE;
 543
 544         ret = voicecall_core_make_private_call(global_pcall_core, call_handle);
 545         if (ret == TRUE) {
 546                 return VCALL_ENGINE_API_SUCCESS;
 547         } else {
 548                 return VCALL_ENGINE_API_FAILED;
 549         }
 550 }
 551
 552 /**
 553  * This function transfers the call from active call to the held call
 554  *
 555  * @return      int     API Result Code.
 556  * @param[in]   int     call_handle
 557  */
 558 int vcall_engine_transfer_call(void)
 559 {
 560         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 561         int ret = FALSE;
 562
 563         ret = voicecall_core_transfer_calls(global_pcall_core);
 564         if (ret == TRUE) {
 565                 return VCALL_ENGINE_API_SUCCESS;
 566         } else {
 567                 return VCALL_ENGINE_API_FAILED;
 568         }
 569 }
 570
 571 /**
 572  * This function processed loud speaker.
 573  *
 574  * @return      int     API Result Code.
 575  * @param[in]   int     bstatus
 576  */
 577 int vcall_engine_process_loudspeaker(int bstatus)
 578 {
 579         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 580         int ret = FALSE;
 581
 582         CALL_ENG_DEBUG(ENG_DEBUG, " bstatus : [%d]\n", bstatus);
 583         if (bstatus) {
 584                 ret = voicecall_service_loudspeaker_on(global_pcall_core);
 585         } else {
 586                 ret = voicecall_service_loudspeaker_off(global_pcall_core);
 587         }
 588
 589         if (ret == TRUE) {
 590                 return VCALL_ENGINE_API_SUCCESS;
 591         } else {
 592                 return VCALL_ENGINE_API_FAILED;
 593         }
 594 }
 595
 596 /**
 597  * This function processed voice mute status.
 598  *
 599  * @return      int     API Result Code.
 600  * @param[in]   int     bstatus
 601  */
 602 int vcall_engine_process_voice_mute(int bstatus)
 603 {
 604         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 605         int ret = FALSE;
 606
 607         CALL_ENG_DEBUG(ENG_DEBUG, " bstatus : [%d]\n", bstatus);
 608         if (bstatus) {
 609                 ret = voicecall_service_mute_status_on(global_pcall_core);
 610         } else {
 611                 ret = voicecall_service_mute_status_off(global_pcall_core);
 612         }
 613
 614         if (ret == TRUE) {
 615                 return VCALL_ENGINE_API_SUCCESS;
 616         } else {
 617                 return VCALL_ENGINE_API_FAILED;
 618         }
 619 }
 620
 621 /**
 622  * This function gets the volume level
 623  *
 624  * @return      int     API Result Code.
 625  * @param[in]           vcall_engine_vol_type_t vol_type
 626  * @param[in]           voicecall_snd_volume_alert_type_t vol_alert_type
 627  */
 628 int vcall_engine_get_volume_level(vcall_engine_vol_type_t vol_type)
 629 {
 630         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 631
 632         CALL_ENG_DEBUG(ENG_DEBUG, " vol_type : [%d]\n", vol_type);
 633
 634         return voicecall_snd_get_volume(global_pcall_core->papp_snd, vol_type);
 635
 636 }
 637
 638 /**
 639  * This function sets the volume level
 640  *
 641  * @return      int     API Result Code.
 642  * @param[in]           vcall_engine_vol_type_t vol_type
 643  * @param[in]           int vol_level
 644  */
 645 int vcall_engine_set_volume_level(vcall_engine_vol_type_t vol_type, int vol_level)
 646 {
 647         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 648         int ret = FALSE;
 649
 650         CALL_ENG_DEBUG(ENG_DEBUG, " vol_type : [%d], vol_level:[%d]\n", vol_type, vol_level);
 651         ret = voicecall_service_set_volume(global_pcall_core, vol_type, vol_level);
 652         if (ret == TRUE) {
 653                 return VCALL_ENGINE_API_SUCCESS;
 654         } else {
 655                 return VCALL_ENGINE_API_FAILED;
 656         }
 657 }
 658
 659 /**
 660  * This function stop alert
 661  *
 662  * @return      int     API Result Code.
 663  * @param[in]           none
 664  */
 665 int vcall_engine_stop_alert(void)
 666 {
 667         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 668         int ret = FALSE;
 669
 670         ret = voicecall_core_stop_alert(global_pcall_core);
 671         if (ret == TRUE) {
 672                 return VCALL_ENGINE_API_SUCCESS;
 673         } else {
 674                 return VCALL_ENGINE_API_FAILED;
 675         }
 676 }
 677
 678 /**
 679  * This function mute alert.
 680  *
 681  * @return int  API Result Code.
 682  * @param[in]           none
 683  */
 684 int vcall_engine_mute_alert(void)
 685 {
 686         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 687         int ret = FALSE;
 688
 689         ret = voicecall_snd_mute_alert(global_pcall_core->papp_snd);
 690         if (ret == TRUE) {
 691                 return VCALL_ENGINE_API_SUCCESS;
 692         } else {
 693                 return VCALL_ENGINE_API_FAILED;
 694         }
 695 }
 696
 697 /**
 698  * This function process auto redial.
 699  *
 700  * @return      int     API Result Code.
 701  * @param[in]           int bstatus
 702  */
 703 int vcall_engine_process_auto_redial(int bstatus)
 704 {
 705         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 706         int ret = FALSE;
 707
 708         CALL_ENG_DEBUG(ENG_DEBUG, " bstatus : [%d]\n", bstatus);
 709         if (bstatus) {
 710                 ret = voicecall_core_start_redial(global_pcall_core, TRUE);
 711         } else {
 712                 ret = voicecall_core_stop_redial(global_pcall_core);
 713         }
 714         if (ret == TRUE) {
 715                 return VCALL_ENGINE_API_SUCCESS;
 716         } else {
 717                 return VCALL_ENGINE_API_FAILED;
 718         }
 719 }
 720
 721 /**
 722  * This function send the DTMF number
 723  *
 724  * @return      int     API Result Code.
 725  * @param[in]           char* dtmf_number
 726  */
 727 int vcall_engine_send_dtmf_number(char *dtmf_number)
 728 {
 729         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 730         int ret = FALSE;
 731
 732         ret = voicecall_core_send_dtmf(global_pcall_core, dtmf_number);
 733
 734         if (ret == TRUE) {
 735                 return VCALL_ENGINE_API_SUCCESS;
 736         } else {
 737                 return VCALL_ENGINE_API_FAILED;
 738         }
 739 }
 740
 741 /**
 742  * This function processed sound path
 743  *
 744  * @return      int     API Result Code.
 745  * @param[in]   int     sound_path
 746  */
 747 int vcall_engine_change_sound_path(vcall_engine_audio_type_t sound_path)
 748 {
 749         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 750         int ret = FALSE;
 751
 752         ret = voicecall_core_change_sound_path(global_pcall_core, sound_path);
 753
 754         if (ret == TRUE) {
 755                 return VCALL_ENGINE_API_SUCCESS;
 756         } else {
 757                 return VCALL_ENGINE_API_FAILED;
 758         }
 759 }
 760
 761 /**
 762  * This function get sound path
 763  *
 764  * @return      int     API Result Code.
 765  * @param[out]  int     sound_path
 766  */
 767 int vcall_engine_get_sound_path(int *sound_path)
 768 {
 769         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 770         int ret = FALSE;
 771         int snd_path = 0;
 772
 773         ret = voicecall_core_get_sound_path(global_pcall_core, &snd_path);
 774
 775         if (snd_path == VOICE_CALL_AUDIO_SPEAKER) {
 776                 *sound_path = VCALL_ENGINE_AUDIO_SPEAKER;
 777         } else if (snd_path == VOICE_CALL_AUDIO_RECEIVER) {
 778                 *sound_path = VCALL_ENGINE_AUDIO_RECEIVER;
 779         } else if (snd_path == VOICE_CALL_AUDIO_HEADSET) {
 780                 *sound_path = VCALL_ENGINE_AUDIO_HEADSET;
 781         } else if (snd_path == VOICE_CALL_AUDIO_EARJACK) {
 782                 *sound_path = VCALL_ENGINE_AUDIO_EARJACK;
 783         } else {
 784                 *sound_path = VCALL_ENGINE_AUDIO_RECEIVER;
 785         }
 786
 787         if (ret == TRUE) {
 788                 return VCALL_ENGINE_API_SUCCESS;
 789         } else {
 790                 return VCALL_ENGINE_API_FAILED;
 791         }
 792 }
 793
 794 /**
 795  * This function set call engine to default
 796  *
 797  * @return      int     API Result Code.
 798  * @param[in]
 799  */
 800 int vcall_engine_set_to_default()
 801 {
 802         CALL_ENG_DEBUG(ENG_WARN, "..\n");
 803         int ret = FALSE;
 804
 805         ret = voicecall_core_set_to_default(global_pcall_core);
 806
 807         if (ret == TRUE) {
 808                 return VCALL_ENGINE_API_SUCCESS;
 809         } else {
 810                 return VCALL_ENGINE_API_FAILED;
 811         }
 812 }
 813
 814 gpointer vcall_engine_get_core_state(void)
 815 {
 816         return global_pcall_core;
 817 }
 818
 819 /**
 820  * This function is interface to call-utility to perform string copy
 821  *
 822  * @return      instance of the core state
 823  * @param[out]  pbuffer         Target Buffer
 824  * @param[in]   buf_count       Size of Target Buffer
 825  * @param[in]   pstring         Source String
 826  */
 827 gboolean vcall_engine_util_strcpy(char *pbuffer, int buf_count, const char *pstring)
 828 {
 829         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 830         return _vc_core_util_strcpy(pbuffer, buf_count, pstring);
 831 }
 832
 833 /**
 834  * This function returns the number of groups
 835  *
 836  * @param[in]           pcount          count of the groups
 837  */
 838 gboolean vcall_engine_get_group_count(int *pcount)
 839 {
 840         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 841         return _vc_core_engine_group_get_enabled_group_count(global_pcall_core->pcall_engine, pcount);
 842 }
 843
 844 /**
 845  * This function is interface to call-utility to perform string copy
 846  *
 847  * @return      instance of the core state
 848  * @param[out]  pbuffer         Target Buffer
 849  * @param[in]   time            time
 850  */
 851 char *vcall_engine_util_get_date_time(time_t time)
 852 {
 853         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 854         return _vc_core_util_get_date_time(time);
 855 }
 856
 857 /**
 858  * This function is force reset all engine status.
 859  *
 860  * @return      void
 861  * @param[in] void
 862  */
 863 void vcall_engine_force_reset(void)
 864 {
 865         CALL_ENG_DEBUG(ENG_DEBUG, "..");
 866
 867         voicecall_snd_unregister_cm(global_pcall_core->papp_snd);
 868
 869         _vc_core_util_set_call_status(VCONFKEY_CALL_OFF);
 870
 871         voicecall_core_end_all_calls(global_pcall_core);
 872 }