ui/vcui-engine-interface.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 "vcui-application.h"
  19 #include "vcui-engine-interface.h"
  20 #include "vcui-view-dialing.h"
  21
  22 /* For Debug Information, Call Event name string constant */
  23 static char *gszcall_callback_msg[VC_ENGINE_MSG_MAX_TO_UI] = {
  24         "VC_ENGINE_MSG_INCOM_TO_UI",
  25         "VC_ENGINE_MSG_OUTGOING_TO_UI",
  26         "VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI",
  27         "VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI_TEST",
  28         "VC_ENGINE_MSG_OUTGOING_ALERT_TO_UI",
  29         "VC_ENGINE_MSG_CONNECTED_TO_UI",
  30         "VC_ENGINE_MSG_NORMAL_END_TO_UI",
  31         "VC_ENGINE_MSG_INCOM_END_TO_UI",
  32         "VC_ENGINE_MSG_REJECTED_END_TO_UI",
  33         "VC_ENGINE_MSG_OUTGOING_END_TO_UI",
  34         "VC_ENGINE_MSG_OUTGOING_END_SIGNAL_PLAY_TO_UI",
  35         "VC_ENGINE_MSG_OUTGOING_ABORTED_TO_UI",
  36         "VC_ENGINE_MSG_DTMF_ACK_TO_UI",
  37
  38         "VC_ENGINE_MSG_SS_HELD_TO_UI",
  39         "VC_ENGINE_MSG_SS_RETREIVED_TO_UI",
  40         "VC_ENGINE_MSG_SS_SWAP_TO_UI",
  41         "VC_ENGINE_MSG_SS_SETUP_CONF_TO_UI",
  42         "VC_ENGINE_MSG_SS_SPLIT_CONF_TO_UI",
  43         "VC_ENGINE_MSG_SS_TRANSFERRED_TO_UI",
  44         "VC_ENGINE_MSG_SS_CONNECT_LINE_IND_TO_UI",
  45
  46         "VC_ENGINE_MSG_IND_FORWARD_TO_UI",
  47         "VC_ENGINE_MSG_IND_ACTIVATE_TO_UI",
  48         "VC_ENGINE_MSG_IND_HOLD_TO_UI",
  49         "VC_ENGINE_MSG_IND_TRANSFER_TO_UI",
  50         "VC_ENGINE_MSG_IND_SETUPCONFERENCE_TO_UI",
  51         "VC_ENGINE_MSG_IND_BARRING_TO_UI",
  52         "VC_ENGINE_MSG_IND_WAITING_TO_UI",
  53         "VC_ENGINE_MSG_IND_CUGINFO_TO_UI",
  54         "VC_ENGINE_MSG_IND_SSNOTIFY_TO_UI",
  55         "VC_ENGINE_MSG_IND_CALLINGNAMEINFO_TO_UI",
  56         "VC_ENGINE_MSG_IND_REDIRECT_CNF_TO_UI",
  57         "VC_ENGINE_MSG_IND_ACTIVATECCBS_CNF_TO_UI",
  58         "VC_ENGINE_MSG_IND_ACTIVATECCBS_USERINFO_TO_UI",
  59         "VC_ENGINE_MSG_IND_AOC_TO_UI",
  60
  61         "VC_ENGINE_MSG_ERROR_OCCURED_TO_UI",
  62
  63         "VC_ENGINE_MSG_ACTION_INCOM_FORCE_TO_UI",
  64         "VC_ENGINE_MSG_ACTION_SAT_REQUEST_TO_UI",
  65         "VC_ENGINE_MSG_ACTION_SAT_RESPONSE_TO_UI",
  66         "VC_ENGINE_MSG_ACTION_CALL_END_HELD_RETREIVED_TO_UI",
  67         "VC_ENGINE_MSG_ACTION_NO_ACTIVE_TASK_TO_UI",
  68
  69         "VC_ENGINE_MSG_GET_VOLUME_RESP_TO_UI",
  70         "VC_ENGINE_MSG_SET_VOLUME_FROM_BT_TO_UI",
  71         "VC_ENGINE_MSG_HEADSET_STATUS_TO_UI",
  72         "VC_ENGINE_MSG_EARJACK_STATUS_TO_UI",
  73
  74         "VC_ENGINE_MSG_ACCEPT_CHOICE_BOX_TO_UI",
  75         "VC_ENGINE_MSG_MESSAGE_BOX_TO_UI",
  76
  77         "VC_ENGINE_MSG_REDIAL_TO_UI",
  78         "VC_ENGINE_MSG_STOPPED_RECORDING_TO_UI",
  79         "VC_ENGINE_MSG_CREATE_NEWVOICEFILE_TO_UI",
  80 };
  81
  82 static char *gszcall_error_msg[IDS_CALL_MAX] = {
  83         "IDS_CALL_POP_CALL_IS_DIVERTED",
  84         "IDS_CALL_POP_CALLFAILED",
  85         "IDS_CALL_POP_CALLING_EMERG_ONLY",
  86         "IDS_CALL_POP_CALLNOTCALLOWED",
  87         "IDS_CALL_POP_CAUSE_WRONG_NUMBER",
  88         "IDS_CALL_POP_CHANGEOFFLINEMODETOCALL",
  89         "IDS_CALL_POP_DTMFSENDING_FAIL",
  90         "IDS_CALL_POP_FDNCALLONLY",
  91         "IDS_CALL_POP_HOLD_FAILED",
  92         "IDS_CALL_POP_HOLD_NOT_SUPPORTED",
  93         "IDS_CALL_POP_INCOMPLETE",
  94         "IDS_CALL_POP_JOIN_FAILED",
  95         "IDS_CALL_POP_JOIN_NOT_SUPPORTED",
  96         "IDS_CALL_POP_OPERATION_REFUSED",
  97         "IDS_CALL_POP_PHONE_NOT_INITIALISED",
  98         "IDS_CALL_POP_REJECTED",
  99         "IDS_CALL_POP_SENDING",
 100         "IDS_CALL_POP_SOS_CALL_ONLY_IN_NO_SIM_MODE",
 101         "IDS_CALL_POP_SPLIT_FAILED",
 102         "IDS_CALL_POP_SPLIT_NOT_SUPPORTED",
 103         "IDS_CALL_POP_SWAP_FAILED",
 104         "IDS_CALL_POP_SWAP_NOT_SUPPORTED",
 105         "IDS_CALL_POP_TRANSFER_FAILED",
 106         "IDS_CALL_POP_TRANSFER_NOT_SUPPORTED",
 107         "IDS_CALL_POP_UNABLE_TO_RETRIEVE",
 108         "IDS_CALL_POP_UNAVAILABLE",
 109         "IDS_CALL_POP_UNHOLD_NOT_SUPPORTED",
 110         "IDS_CALL_POP_VOICE_CALL_IS_NOT_ALLOWED_DURING_VIDEO_CALL",
 111         "IDS_CALL_POP_WAITING_ACTIVE",
 112         "IDS_CALL_BODY_CALLENDED",
 113         "Invalid DTMF",
 114         "Sent"
 115 };
 116
 117 void _vcui_engine_init(vcui_app_call_data_t *ad)
 118 {
 119         CALL_UI_DEBUG("..");
 120         vcall_engine_init((vcall_engine_app_cb) _vcui_engine_callback, ad);
 121         CALL_UI_DEBUG("End..");
 122 }
 123
 124 void _vcui_engine_answer_call(void)
 125 {
 126         int ret = VCALL_ENGINE_API_SUCCESS;
 127
 128         CALL_UI_DEBUG("..");
 129
 130         ret = vcall_engine_answer_call();
 131
 132         CALL_UI_DEBUG("End..");
 133 }
 134
 135 void _vcui_engine_answer_call_by_type(int ans_type)
 136 {
 137         CALL_UI_DEBUG("..");
 138
 139         vcall_engine_answer_call_by_type(ans_type);
 140
 141         CALL_UI_DEBUG("End..");
 142 }
 143
 144 void _vcui_engine_cancel_call(void)
 145 {
 146         CALL_UI_DEBUG("..");
 147
 148         vcall_engine_cancel_call();
 149
 150         CALL_UI_DEBUG("End..");
 151 }
 152
 153 void _vcui_engine_reject_call(void)
 154 {
 155         CALL_UI_DEBUG("..");
 156
 157         vcall_engine_reject_call();
 158
 159         CALL_UI_DEBUG("End..");
 160 }
 161
 162 void _vcui_engine_set_volume_level(vcui_vol_type_t vol_type, int level)
 163 {
 164         int vol = 0;
 165         vcall_engine_vol_type_t engine_vol_type = VCALL_ENGINE_VOL_TYPE_RINGTONE;
 166         CALL_UI_DEBUG("..");
 167
 168         if (vol_type == VCUI_VOL_RING) {
 169                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_RINGTONE;
 170         } else if (vol_type == VCUI_VOL_VOICE) {
 171                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_VOICE;
 172         } else if (vol_type == VCUI_VOL_HEADSET) {
 173                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_HEADSET;
 174         }
 175
 176         vol = vcall_engine_set_volume_level(engine_vol_type, level);
 177         CALL_UI_DEBUG("End..");
 178 }
 179
 180 int _vcui_engine_get_volume_level(vcui_vol_type_t vol_type)
 181 {
 182         int vol = 0;
 183         vcall_engine_vol_type_t engine_vol_type = VCALL_ENGINE_VOL_TYPE_RINGTONE;
 184         CALL_UI_DEBUG("vol_type(%d)", vol_type);
 185
 186         if (vol_type == VCUI_VOL_RING) {
 187                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_RINGTONE;
 188         } else if (vol_type == VCUI_VOL_VOICE) {
 189                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_VOICE;
 190         } else if (vol_type == VCUI_VOL_HEADSET) {
 191                 engine_vol_type = VCALL_ENGINE_VOL_TYPE_HEADSET;
 192         }
 193
 194         vol = vcall_engine_get_volume_level(engine_vol_type);
 195         CALL_UI_DEBUG("End..");
 196
 197         return vol;
 198 }
 199
 200 void _vcui_engine_change_sound_path(vcui_audio_type_t sound_path)
 201 {
 202         int ret = 0;
 203         vcall_engine_audio_type_t rqst_snd_path = VCALL_ENGINE_AUDIO_NONE;
 204         CALL_UI_DEBUG("sound_path(%d)", sound_path);
 205
 206         if (sound_path == VCUI_AUDIO_SPEAKER) {
 207                 rqst_snd_path = VCALL_ENGINE_AUDIO_SPEAKER;
 208         } else if (sound_path == VCUI_AUDIO_HEADSET) {
 209                 rqst_snd_path = VCALL_ENGINE_AUDIO_HEADSET;
 210         } else if (sound_path == VCUI_AUDIO_EARJACK) {
 211                 rqst_snd_path = VCALL_ENGINE_AUDIO_EARJACK;
 212         }
 213
 214         vcall_engine_change_sound_path(rqst_snd_path);
 215         CALL_UI_DEBUG("End..");
 216 }
 217
 218 vcui_audio_type_t _vcui_engine_get_sound_path(void)
 219 {
 220         int ret = 0;
 221         int snd_path = VCALL_ENGINE_AUDIO_NONE;
 222
 223         ret = vcall_engine_get_sound_path(&snd_path);
 224
 225         if (snd_path == VCALL_ENGINE_AUDIO_SPEAKER) {
 226                 return VCUI_AUDIO_SPEAKER;
 227         } else if (snd_path == VCALL_ENGINE_AUDIO_HEADSET) {
 228                 return VCUI_AUDIO_HEADSET;
 229         } else if (snd_path == VCALL_ENGINE_AUDIO_EARJACK) {
 230                 return VCUI_AUDIO_EARJACK;
 231         } else if (snd_path == VCALL_ENGINE_AUDIO_RECEIVER) {
 232                 return VCUI_AUDIO_RECEIVER;
 233         } else {
 234                 return VCALL_ENGINE_AUDIO_NONE;
 235         }
 236 }
 237
 238 void _vcui_engine_stop_alert(void)
 239 {
 240         CALL_UI_DEBUG("..");
 241
 242         vcall_engine_stop_alert();
 243
 244         CALL_UI_DEBUG("End..");
 245 }
 246
 247 void _vcui_engine_end_call(void)
 248 {
 249         CALL_UI_DEBUG("..");
 250
 251         vcall_engine_release_call();
 252
 253         CALL_UI_DEBUG("End..");
 254 }
 255
 256 void _vcui_engine_end_call_by_handle(int handle)
 257 {
 258         CALL_UI_DEBUG("handle(%d)",handle);
 259
 260         vcall_engine_release_call_by_handle(handle);
 261
 262         CALL_UI_DEBUG("End..");
 263 }
 264
 265 void _vcui_engine_end_all_call(void)
 266 {
 267         CALL_UI_DEBUG("..");
 268
 269         vcall_engine_release_call_by_type(VCALL_ENGINE_RELEASE_ALL_CALLS);
 270
 271         CALL_UI_DEBUG("End..");
 272 }
 273
 274 void _vcui_engine_end_active_calls(void)
 275 {
 276         CALL_UI_DEBUG("..");
 277
 278         vcall_engine_release_call_by_type(VCALL_ENGINE_RELEASE_ALL_ACTIVE_CALLS);
 279
 280         CALL_UI_DEBUG("End..");
 281 }
 282
 283 void _vcui_engine_end_held_calls(void)
 284 {
 285         CALL_UI_DEBUG("..");
 286
 287         vcall_engine_release_call_by_type(VCALL_ENGINE_RELEASE_ALL_HELD_CALLS);
 288
 289         CALL_UI_DEBUG("End..");
 290 }
 291
 292 void _vcui_engine_hold_unhold_swap_call(void)
 293 {
 294         CALL_UI_DEBUG("..");
 295
 296         vcall_engine_process_hold_call();
 297
 298         CALL_UI_DEBUG("End..");
 299 }
 300
 301 void _vcui_engine_join_call(void)
 302 {
 303         CALL_UI_DEBUG("..");
 304
 305         vcall_engine_join_call();
 306
 307         CALL_UI_DEBUG("End..");
 308 }
 309
 310 void _vcui_engine_split_call(int call_handle)
 311 {
 312         CALL_UI_DEBUG("..");
 313
 314         vcall_engine_split_call(call_handle);
 315
 316         CALL_UI_DEBUG("End..");
 317 }
 318
 319 void _vcui_engine_transfer_call(void)
 320 {
 321         CALL_UI_DEBUG("..");
 322
 323         vcall_engine_transfer_call();
 324
 325         CALL_UI_DEBUG("End..");
 326 }
 327
 328 void _vcui_engine_speaker_on_off(int bLoundSpeaker)
 329 {
 330         CALL_UI_DEBUG("..");
 331
 332         vcall_engine_process_loudspeaker(bLoundSpeaker);
 333
 334         CALL_UI_DEBUG("End..");
 335 }
 336
 337 void _vcui_engine_mute_on_off(int bMute)
 338 {
 339         CALL_UI_DEBUG("..");
 340
 341         vcall_engine_process_voice_mute(bMute);
 342
 343         CALL_UI_DEBUG("End..");
 344 }
 345
 346 void _vcui_engine_interface_process_auto_redial(int bRedial)
 347 {
 348         CALL_UI_DEBUG("..");
 349
 350         vcall_engine_process_auto_redial(bRedial);
 351
 352         CALL_UI_DEBUG("End..");
 353 }
 354
 355 void _vcui_engine_interface_process_mute_alert(void)
 356 {
 357         CALL_UI_DEBUG("..");
 358
 359         vcall_engine_mute_alert();
 360
 361         CALL_UI_DEBUG("End..");
 362 }
 363
 364 void _vcui_engine_interface_send_dtmf_number(char data)
 365 {
 366         CALL_UI_DEBUG("..");
 367         char dtmf_number[2];
 368
 369         dtmf_number[0] = data;
 370         dtmf_number[1] = '\0';
 371
 372         vcall_engine_send_dtmf_number(dtmf_number);
 373
 374         CALL_UI_DEBUG("End..");
 375 }
 376
 377 void _vcui_engine_interface_process_mo_call(vcui_call_type_t call_type, vcui_call_mo_data_t *data)
 378 {
 379         CALL_UI_DEBUG(".");
 380
 381         CALL_UI_KPI("vcall_engine_process_normal_call start");
 382         vcui_call_mo_data_t *mocall = (vcui_call_mo_data_t *) data;
 383         CALL_UI_DEBUG("number is : [%s] ", mocall->call_number);
 384
 385         if (call_type == VCUI_CALL_TYPE_MO)
 386                 vcall_engine_process_normal_call(mocall->call_number, mocall->ct_index, EINA_FALSE);
 387         else if (call_type == VCUI_CALL_TYPE_DOWNLOAD_CALL)
 388                 vcall_engine_process_normal_call(mocall->call_number, mocall->ct_index, EINA_TRUE);
 389
 390         CALL_UI_KPI("vcall_engine_process_normal_call done");
 391
 392 }
 393
 394 void _vcui_engine_interface_process_mt_call(vcui_call_type_t call_type, vcui_call_mt_data_t *data)
 395 {
 396         CALL_UI_KPI("vcall_engine_process_incoming_call start");
 397         vcui_call_mt_data_t *mtcall = (vcui_call_mt_data_t *) data;
 398         vcall_engine_incoming_info_t mtcall_info;
 399         CALL_UI_DEBUG("number is : [%s] ", mtcall->call_num);
 400
 401         mtcall_info.call_handle = mtcall->call_handle;
 402         mtcall_info.call_type = mtcall->call_type;
 403         mtcall_info.cli_presentation_indicator = mtcall->cli_presentation_indicator;
 404         _vc_core_util_strcpy(mtcall_info.call_num, sizeof(mtcall_info.call_num), mtcall->call_num);
 405         mtcall_info.calling_name_mode = mtcall->calling_name_mode;
 406         _vc_core_util_strcpy(mtcall_info.calling_name, sizeof(mtcall_info.calling_name), mtcall->calling_name);
 407         _vc_core_util_strcpy(mtcall_info.redirected_number, sizeof(mtcall_info.redirected_number), mtcall->redirected_number);
 408         _vc_core_util_strcpy(mtcall_info.redirected_sub_address, sizeof(mtcall_info.redirected_sub_address), mtcall->redirected_sub_address);
 409         mtcall_info.cli_cause = mtcall->cli_cause;
 410         mtcall_info.bfwded = mtcall->bfwded;
 411         mtcall_info.active_line = mtcall->active_line;
 412
 413         vcall_engine_process_incoming_call(&mtcall_info);
 414         CALL_UI_KPI("vcall_engine_process_incoming_call done");
 415 }
 416
 417 void _vcui_engine_interface_process_ecc_call(vcui_call_type_t call_type, vcui_call_ecc_data_t *data)
 418 {
 419         vcui_call_ecc_data_t *emercall = (vcui_call_ecc_data_t *) data;
 420
 421         CALL_UI_DEBUG("number is : [%s] ", emercall->call_number);
 422         if (call_type == VCUI_CALL_TYPE_ECC)
 423                 vcall_engine_process_emergency_call(emercall->call_number);
 424         else if (call_type == VCUI_CALL_TYPE_ECC_TEST)
 425                 vcall_engine_process_emergency_call_test(emercall->call_number);
 426
 427 }
 428
 429 void _vcui_engine_interface_process_sat_call(vcui_call_type_t call_type, vcui_call_sat_data_t *data)
 430 {
 431         vcui_call_sat_data_t *satcall = (vcui_call_sat_data_t *) data;
 432         vcall_engine_sat_setup_call_info_t sat_setup_call_info;
 433         CALL_UI_DEBUG("..");
 434
 435         memset(&sat_setup_call_info, 0, sizeof(sat_setup_call_info));
 436         sat_setup_call_info.command_id = satcall->command_id;
 437         sat_setup_call_info.command_qualifier = satcall->command_qualifier;
 438         sat_setup_call_info.duration = satcall->duration;
 439         memcpy(sat_setup_call_info.disp_text, satcall->disp_text, sizeof(sat_setup_call_info.disp_text));
 440         memcpy(sat_setup_call_info.call_num, satcall->call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 441
 442         vcall_engine_process_sat_setup_call(&sat_setup_call_info);
 443 }
 444
 445 void _vcui_engine_callback(int event, void *pdata, void *puser_data)
 446 {
 447         vcui_app_call_data_t *ad = (vcui_app_call_data_t *) puser_data;
 448         vc_engine_msg_type *msg = (vc_engine_msg_type *)pdata;
 449
 450         if ((ad == NULL) || (msg == NULL)) {
 451                 CALL_UI_DEBUG("ERROR.NULL pointer");
 452                 return;
 453         }
 454         CALL_UI_DEBUG("@@@ event:[%s], view_top:[%d], count:[%d]  @@@ \n", gszcall_callback_msg[event], ad->view_top, _vcui_doc_get_count());
 455
 456         switch (event) {
 457         case VC_ENGINE_MSG_INCOM_TO_UI:
 458                 {
 459                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_LOCK);
 460
 461                         CALL_UI_DEBUG("num:[%s], name:[%s]", msg->incoming.call_num, msg->incoming.call_name);
 462
 463                         call_data_t *call_data = malloc(sizeof(call_data_t));
 464                         if (call_data == NULL)
 465                                 return;
 466                         memset(call_data, 0, sizeof(call_data_t));
 467
 468                         call_data->call_handle = msg->incoming.call_handle;
 469                         call_data->contact_id = msg->incoming.contact_index;
 470                         call_data->contact_phone_type = msg->incoming.phone_type;
 471                         vcall_engine_util_strcpy(call_data->call_num, sizeof(call_data->call_num), msg->incoming.call_num);
 472                         if (msg->incoming.brestricted == EINA_TRUE) {
 473                                 if (msg->incoming.bpayphone == EINA_TRUE) {
 474                                         vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, _("Payphone"));
 475                                 } else {
 476                                         vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 477                                 }
 478                         } else {
 479                                 vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, msg->incoming.call_name);
 480                         }
 481
 482                         if (strcmp((char *)msg->incoming.call_file_path, "default") == 0)
 483                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 484                         else if (strlen((char *)msg->incoming.call_file_path) == 0)
 485                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 486                         else
 487                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, msg->incoming.call_file_path);
 488
 489                         if (strcmp((char *)msg->incoming.call_full_file_path, "default") == 0)
 490                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 491                         else if (strlen((char *)msg->incoming.call_full_file_path) == 0)
 492                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 493                         else
 494                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, msg->incoming.call_full_file_path);
 495
 496                         call_data->caller_status = NO_STATUS;
 497                         call_data->mo_mt_status = CALL_INCOMING;
 498
 499                         _vcui_doc_set_mt_recent(call_data);
 500                         _vcui_doc_add_call_data(call_data);
 501
 502                         if (_vcui_is_idle_lock() == CALL_LOCK) {
 503                                 _vcui_view_change(VIEW_INCOMING_LOCK_VIEW, 0, NULL, NULL);
 504                         } else {
 505                                 _vcui_view_change(VIEW_INCOMING_VIEW, 0, NULL, NULL);
 506                         }
 507                 }
 508                 break;
 509
 510         case VC_ENGINE_MSG_OUTGOING_TO_UI:
 511                 {
 512                         call_data_t *call_data = malloc(sizeof(call_data_t));
 513                         if (call_data == NULL)
 514                                 return;
 515                         memset(call_data, 0, sizeof(call_data_t));
 516
 517                         call_data->call_handle = NO_HANDLE;
 518                         call_data->contact_id = msg->outgoing.contact_index;
 519                         call_data->contact_phone_type = msg->outgoing.phone_type;
 520                         vcall_engine_util_strcpy(call_data->call_num, VC_PHONE_NUMBER_LENGTH_MAX, msg->outgoing.call_num);
 521                         vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, msg->outgoing.call_name);
 522
 523                         if (strcmp((char *)msg->outgoing.call_file_path, "default") == 0)
 524                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 525                         else if (strlen((char *)msg->outgoing.call_file_path) == 0)
 526                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 527                         else
 528                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, msg->outgoing.call_file_path);
 529
 530                         if (strcmp((char *)msg->outgoing.call_full_file_path, "default") == 0)
 531                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 532                         else if (strlen((char *)msg->outgoing.call_full_file_path) == 0)
 533                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 534                         else
 535                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, msg->outgoing.call_full_file_path);
 536
 537                         call_data->caller_status = NO_STATUS;
 538                         call_data->mo_mt_status = CALL_OUTGOING;
 539                         call_data->start_time = time(&(call_data->start_time));
 540
 541                         _vcui_doc_set_mo_recent(call_data);
 542
 543                 }
 544                 break;
 545
 546         case VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI:
 547                 {
 548                         if (_voicecall_dvc_get_proximity_sensor_state() != VCALL_SENSOR_NEAR)
 549                                 _voicecall_dvc_control_lcd_state(VC_LCD_ON_LOCK);
 550
 551                         vc_engine_outgoing_orig_type outgoing_orig = msg->outgoing_orig;
 552
 553                         call_data_t *call_data = _vcui_doc_get_recent_mo();
 554                         call_data->call_handle = outgoing_orig.call_handle;
 555
 556                         if (outgoing_orig.bemergency == EINA_TRUE) {
 557                                 CALL_UI_DEBUG("it is emergency call");
 558                                 char *em_name = _("IDS_CALL_POP_EMERGENCY_CALL");
 559
 560                                 memset(call_data->call_display, 0, sizeof(call_data->call_display));
 561                                 memset(call_data->call_file_path, 0, sizeof(call_data->call_file_path));
 562                                 memset(call_data->call_full_file_path, 0, sizeof(call_data->call_full_file_path));
 563
 564                                 vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, em_name);
 565                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 566                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 567                                 call_data->contact_phone_type = -1;
 568                         }
 569
 570                         _vcui_doc_add_call_data(call_data);
 571                         _vcui_view_change(VIEW_DIALLING_VIEW, 0, NULL, NULL);
 572                 }
 573                 break;
 574
 575         case VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI_TEST:
 576                 {
 577                         if (_voicecall_dvc_get_proximity_sensor_state() != VCALL_SENSOR_NEAR)
 578                                 _voicecall_dvc_control_lcd_state(VC_LCD_ON_LOCK);
 579
 580                         vc_engine_outgoing_orig_type outgoing_orig = msg->outgoing_orig;
 581
 582                         call_data_t *call_data = _vcui_doc_get_recent_mo();
 583                         call_data->call_handle = 1;
 584
 585                         if (outgoing_orig.bemergency == EINA_TRUE) {
 586                                 CALL_UI_DEBUG("it is emergency call");
 587                                 char *em_name = _("IDS_CALL_POP_EMERGENCY_CALL");
 588
 589                                 memset(call_data->call_display, 0, sizeof(call_data->call_display));
 590                                 memset(call_data->call_file_path, 0, sizeof(call_data->call_file_path));
 591                                 memset(call_data->call_full_file_path, 0, sizeof(call_data->call_full_file_path));
 592
 593                                 vcall_engine_util_strcpy(call_data->call_display, VC_DISPLAY_NAME_LENGTH_MAX, em_name);
 594                                 vcall_engine_util_strcpy(call_data->call_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 595                                 vcall_engine_util_strcpy(call_data->call_full_file_path, VC_IMAGE_PATH_LENGTH_MAX, NOIMG_ICON);
 596                                 call_data->contact_phone_type = -1;
 597                         }
 598
 599                         _vcui_doc_add_call_data(call_data);
 600                         _vcui_view_change(VIEW_DIALLING_VIEW, 0, NULL, NULL);
 601                 }
 602                 break;
 603
 604         case VC_ENGINE_MSG_OUTGOING_ALERT_TO_UI:
 605                 {
 606                         call_data_t *call_data = _vcui_doc_get_recent_mo();
 607
 608                         if (call_data == NULL) {
 609                                 CALL_UI_DEBUG("Error");
 610                                 elm_exit();
 611                                 return;
 612                         }
 613
 614                         if (_vcui_doc_is_call_data(call_data) == EINA_FALSE) {
 615                                 CALL_UI_DEBUG("Error. check outgoing_orig msg.");
 616                                 elm_exit();
 617                                 return;
 618                         }
 619
 620                         _vcui_view_dialing_draw_txt_connecting(ad->view_st[VIEW_DIALLING_VIEW]);
 621                 }
 622                 break;
 623
 624         case VC_ENGINE_MSG_CONNECTED_TO_UI:
 625                 {
 626                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
 627
 628                         vc_engine_connected_type connected = msg->connected;
 629                         call_data_t *call_data = _vcui_doc_get_call_handle(connected.call_handle);
 630
 631                         if (call_data == NULL) {
 632                                 CALL_UI_DEBUG("Error");
 633                                 elm_exit();
 634                                 return;
 635                         }
 636
 637                         call_data->caller_status = CALL_UNHOLD;
 638                         call_data->call_handle = connected.call_handle;
 639                         call_data->start_time = time(&(call_data->start_time));
 640
 641                         /* When new call connected, if it's multiparty call, always show split1 first. */
 642                         ad->bswapped = EINA_FALSE;
 643
 644                         _vcui_view_auto_change();
 645                 }
 646                 break;
 647
 648         case VC_ENGINE_MSG_NORMAL_END_TO_UI:
 649                 {
 650                         vc_engine_normal_end_type normal_end = msg->normal_end;
 651
 652                         CALL_UI_DEBUG("end_cause_type:[%d]", normal_end.end_cause_type);
 653
 654                         call_data_t *call_data = _vcui_doc_get_call_handle(normal_end.call_handle);
 655                         if (call_data == NULL) {
 656                                 CALL_UI_DEBUG("Error");
 657                                 elm_exit();
 658                                 return;
 659                         }
 660                         if (call_data->mo_mt_status == CALL_INCOMING)
 661                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_INCOMMING, call_data, EINA_FALSE);
 662                         else if (call_data->mo_mt_status == CALL_OUTGOING)
 663                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_FALSE);
 664
 665                         time_t start_time;
 666                         memcpy(&start_time, &(call_data->start_time), sizeof(call_data->start_time));
 667
 668                         if (call_data->bno_end_show == EINA_TRUE) {
 669                                 _vcui_doc_remove_call_data(call_data);
 670                                 _vcui_view_common_call_terminate_or_view_change();
 671                         } else {
 672                                 vcui_app_call_data_t *ad = _vcui_get_app_data();
 673                                 if (_vcui_doc_get_count() == 1 && ad->view_top == VIEW_INCALL_ONECALL_VIEW) {
 674                                         ad->call_end_type = CALL_END_TYPE_SINGLE_CALL;
 675                                 }
 676                                 CALL_UI_DEBUG("ad->call_end_type[%d]", ad->call_end_type);
 677                                 if (ad->call_end_type == CALL_END_TYPE_SINGLE_CALL || ad->call_end_type == CALL_END_TYPE_CONF_CALL) {
 678                                         CALL_UI_DEBUG("Show end screen - %d", ad->call_end_type);
 679                                         _vcui_view_change(VIEW_ENDCALL_VIEW, -1, call_data, NULL);
 680                                         ad->call_end_type = CALL_END_TYPE_NONE;
 681                                         CALL_UI_DEBUG("Blink show: end call time");
 682                                         _vcui_view_common_call_end_show(start_time, normal_end.end_cause_type);
 683                                         _vcui_doc_remove_call_data(call_data);
 684                                 }
 685                                 else {
 686                                         _vcui_doc_remove_call_data(call_data);
 687                                         _vcui_view_common_call_terminate_or_view_change();
 688                                 }
 689                         }
 690                 }
 691                 break;
 692
 693         case VC_ENGINE_MSG_INCOM_END_TO_UI:
 694                 {
 695                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
 696
 697                         vc_engine_common_with_handle_type incom_end = msg->incom_end;
 698
 699                         call_data_t *call_data = _vcui_doc_get_call_handle(incom_end.call_handle);
 700                         if (call_data == NULL) {
 701                                 CALL_UI_DEBUG("Error");
 702                                 elm_exit();
 703                                 return;
 704                         }
 705
 706                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN, call_data, EINA_FALSE);
 707                         _vcui_doc_remove_call_data(call_data);
 708
 709                         _vcui_view_common_call_terminate_or_view_change();
 710
 711                 }
 712                 break;
 713
 714         case VC_ENGINE_MSG_REJECTED_END_TO_UI:
 715                 {
 716                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
 717
 718                         vc_engine_common_with_handle_type rejected_end = msg->rejected_end;
 719
 720                         call_data_t *call_data = _vcui_doc_get_call_handle(rejected_end.call_handle);
 721
 722                         if (call_data == NULL) {
 723                                 CALL_UI_DEBUG("Error");
 724                                 elm_exit();
 725
 726                                 return;
 727                         }
 728
 729                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_REJECT, call_data, EINA_FALSE);
 730                         _vcui_doc_remove_call_data(call_data);
 731                         _vcui_view_common_call_terminate_or_view_change();
 732                 }
 733                 break;
 734
 735         case VC_ENGINE_MSG_OUTGOING_END_TO_UI:
 736                 {
 737                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
 738
 739                         vc_engine_outgoing_end_type outgoing_end = msg->outgoing_end;
 740                         call_data_t *call_data = _vcui_doc_get_call_handle(outgoing_end.call_handle);
 741
 742                         if (call_data == NULL) {
 743                                 CALL_UI_DEBUG("It is the case which call orig is not received.");
 744                                 char data[VC_DATA_LENGTH_MAX] = { 0, };
 745                                 _vcui_view_popup_load(_vcui_get_endcause_string(outgoing_end.end_cause_type, data), POPUP_TIMEOUT_LONG, EINA_TRUE);
 746                         } else {
 747                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_TRUE);
 748                                 if (outgoing_end.bauto_redial == EINA_TRUE) {
 749                                         CALL_UI_DEBUG("bauto_redial is EINA_TRUE");
 750                                         _vcui_doc_remove_call_data_only_list(call_data);
 751                                 } else {
 752                                         CALL_UI_DEBUG("show the call end screen");
 753                                         vcui_app_call_data_t *ad = _vcui_get_app_data();
 754                                         if (_vcui_doc_get_count() == 1 && ad->view_top == VIEW_DIALLING_VIEW) {
 755                                                 ad->call_end_type = CALL_END_TYPE_SINGLE_CALL;
 756                                                 _vcui_view_change(VIEW_ENDCALL_VIEW, -1, call_data, NULL);
 757                                         }
 758                                         _vcui_doc_remove_call_data(call_data);
 759                                 }
 760                                 _vcui_view_common_call_end_show_dialing(outgoing_end.end_cause_type, outgoing_end.bauto_redial);
 761                         }
 762
 763                 }
 764                 break;
 765
 766         case VC_ENGINE_MSG_OUTGOING_END_SIGNAL_PLAY_TO_UI:
 767                 {
 768                         vc_engine_outgoing_end_signal_play_type outgoing_end_signal_play = msg->outgoing_end_signal_play;
 769                         call_data_t *call_data = _vcui_doc_get_call_handle(outgoing_end_signal_play.call_handle);
 770
 771                         if (call_data != NULL) {
 772                                 _vcui_view_dialing_draw_txt_ended(ad->view_st[ad->view_top], outgoing_end_signal_play.end_cause_type);
 773                         } else {
 774                                 CALL_UI_DEBUG("Check it whether call data exists. handle:[%d]", outgoing_end_signal_play.call_handle);
 775                         }
 776                 }
 777                 break;
 778
 779         case VC_ENGINE_MSG_OUTGOING_ABORTED_TO_UI:
 780                 {
 781                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
 782
 783                         vc_engine_common_with_handle_type outgoing_aborted = msg->outgoing_aborted;
 784                         call_data_t *call_data = _vcui_doc_get_call_handle(outgoing_aborted.call_handle);
 785
 786                         if (call_data == NULL)
 787                                 call_data = _vcui_doc_get_recent_mo();
 788
 789                         if (call_data == NULL) {
 790                                 CALL_UI_DEBUG("Error");
 791                                 elm_exit();
 792                                 return;
 793                         }
 794
 795                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_TRUE);
 796
 797                         _vcui_doc_remove_call_data(call_data);
 798
 799                         _vcui_view_common_call_terminate_or_view_change();
 800
 801                 }
 802                 break;
 803
 804         case VC_ENGINE_MSG_DTMF_ACK_TO_UI:
 805                 {
 806 #ifdef  PDIAL_SEND_DTMF
 807
 808                         vc_engine_dtmf_ack_type dtmf_ack = msg->dtmf_progress;
 809
 810                         if (EINA_FALSE == dtmf_ack.bstatus) {
 811                                 _vcui_view_popup_unload_progress(ad);
 812                                 if ((dtmf_ack.string_id != -1) && (dtmf_ack.string_id != IDS_CALL_POP_DTMF_SENT)) {
 813                                         CALL_UI_DEBUG("load popup window... Start");
 814                                         _vcui_view_popup_load(_(gszcall_error_msg[dtmf_ack.string_id]), POPUP_TIMEOUT_LONG, EINA_FALSE);
 815                                 }
 816                         } else {
 817                                 CALL_UI_DEBUG("display_string:[%s], string_id:[%d]", dtmf_ack.display_string, dtmf_ack.string_id);
 818                                 _vcui_view_popup_load_sending_dtmf(_(gszcall_error_msg[dtmf_ack.string_id]), dtmf_ack.display_string);
 819                         }
 820 #endif
 821                 }
 822                 break;
 823
 824         case VC_ENGINE_MSG_SS_HELD_TO_UI:
 825                 {
 826                         _vcui_doc_set_hold_all();
 827                         _vcui_view_update();
 828                 }
 829                 break;
 830
 831         case VC_ENGINE_MSG_SS_RETREIVED_TO_UI:
 832                 {
 833                         _vcui_doc_set_unhold_all();
 834                         _vcui_view_update();
 835                 }
 836                 break;
 837
 838         case VC_ENGINE_MSG_SS_SWAP_TO_UI:
 839                 {
 840                         _vcui_view_popup_unload(ad->popup_eo);
 841
 842                         if (ad->bholdisleft == EINA_TRUE) {
 843                                 ad->bswapped = EINA_FALSE;
 844                         } else {
 845                                 ad->bswapped = EINA_TRUE;
 846                         }
 847
 848                         _vcui_doc_set_swap_all();
 849                         _vcui_view_auto_change();
 850                 }
 851                 break;
 852
 853         case VC_ENGINE_MSG_SS_SETUP_CONF_TO_UI:
 854                 {
 855                         _vcui_view_popup_unload(ad->popup_eo);
 856
 857                         _vcui_doc_set_unhold_all();
 858                         _vcui_view_auto_change();
 859                 }
 860                 break;
 861
 862         case VC_ENGINE_MSG_SS_SPLIT_CONF_TO_UI:
 863                 {
 864                         vc_engine_common_with_handle_type ss_split_conf = msg->ss_split_conf;
 865
 866                         CALL_UI_DEBUG("[UI]The handle is %d ", ss_split_conf.call_handle);
 867
 868                         call_data_t *call_data = _vcui_doc_get_call_handle(ss_split_conf.call_handle);
 869                         if (call_data == NULL) {
 870                                 CALL_UI_DEBUG("Error");
 871                                 elm_exit();
 872                                 return;
 873                         } else {
 874                                 _vcui_doc_set_hold_all();
 875                                 call_data->caller_status = CALL_UNHOLD;
 876
 877                                 _vcui_view_auto_change();
 878                         }
 879                 }
 880                 break;
 881
 882         case VC_ENGINE_MSG_SS_TRANSFERRED_TO_UI:
 883                 break;
 884
 885         case VC_ENGINE_MSG_SS_CONNECT_LINE_IND_TO_UI:
 886                 break;
 887
 888         case VC_ENGINE_MSG_IND_FORWARD_TO_UI:
 889                 break;
 890
 891         case VC_ENGINE_MSG_IND_ACTIVATE_TO_UI:
 892                 {
 893                         _vcui_view_popup_load(_("IDS_CALL_POP_UNHELD"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
 894                 }
 895                 break;
 896
 897         case VC_ENGINE_MSG_IND_HOLD_TO_UI:
 898                 {
 899                         _vcui_view_popup_load(_("IDS_CALL_POP_HELD"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
 900                 }
 901                 break;
 902
 903         case VC_ENGINE_MSG_IND_TRANSFER_TO_UI:
 904                 break;
 905
 906         case VC_ENGINE_MSG_IND_SETUPCONFERENCE_TO_UI:
 907                 break;
 908
 909         case VC_ENGINE_MSG_IND_BARRING_TO_UI:
 910                 break;
 911
 912         case VC_ENGINE_MSG_IND_WAITING_TO_UI:
 913                 {
 914                         _vcui_view_popup_load(_("IDS_CALL_POP_WAITING_ACTIVE"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
 915                 }
 916                 break;
 917
 918         case VC_ENGINE_MSG_IND_CUGINFO_TO_UI:
 919                 break;
 920
 921         case VC_ENGINE_MSG_IND_SSNOTIFY_TO_UI:
 922                 break;
 923
 924         case VC_ENGINE_MSG_IND_CALLINGNAMEINFO_TO_UI:
 925                 break;
 926
 927         case VC_ENGINE_MSG_IND_REDIRECT_CNF_TO_UI:
 928                 break;
 929
 930         case VC_ENGINE_MSG_IND_ACTIVATECCBS_CNF_TO_UI:
 931                 break;
 932
 933         case VC_ENGINE_MSG_IND_ACTIVATECCBS_USERINFO_TO_UI:
 934                 break;
 935
 936         case VC_ENGINE_MSG_GET_VOLUME_RESP_TO_UI:
 937                 {
 938                         vc_engine_vol_resp_type vol_resp = msg->vol_resp;
 939                         _vcui_response_volume(vol_resp.vol_alert_type, vol_resp.vol_level);
 940                 }
 941                 break;
 942
 943         case VC_ENGINE_MSG_SET_VOLUME_FROM_BT_TO_UI:
 944                 {
 945                         vc_engine_vol_set_from_bt_type vol_set_from_bt = msg->vol_set_from_bt;
 946                         ad->bt_vol_val = vol_set_from_bt.vol_level;
 947                         _vcui_view_popup_vol_bt(ad->bt_vol_val);
 948                 }
 949                 break;
 950
 951         case VC_ENGINE_MSG_ACTION_NO_ACTIVE_TASK_TO_UI:
 952                 {
 953
 954                 }
 955                 break;
 956
 957         case VC_ENGINE_MSG_ACTION_CALL_END_HELD_RETREIVED_TO_UI:
 958                 {
 959
 960                 }
 961                 break;
 962
 963         case VC_ENGINE_MSG_ACTION_SAT_RESPONSE_TO_UI:
 964                 {
 965
 966                 }
 967                 break;
 968
 969         case VC_ENGINE_MSG_ACTION_SAT_REQUEST_TO_UI:
 970                 {
 971
 972                 }
 973                 break;
 974
 975         case VC_ENGINE_MSG_ERROR_OCCURED_TO_UI:
 976                 break;
 977
 978         case VC_ENGINE_MSG_IND_AOC_TO_UI:
 979                 break;
 980
 981         case VC_ENGINE_MSG_ACCEPT_CHOICE_BOX_TO_UI:
 982                 {
 983                         CALL_UI_DEBUG("not supported");
 984                 }
 985                 break;
 986
 987         case VC_ENGINE_MSG_HEADSET_STATUS_TO_UI:
 988                 {
 989                         vc_engine_headset_status_type headset_status = msg->headset_status;
 990                         ad->headset_status = headset_status.bstatus;
 991                         if (ad->headset_status == EINA_TRUE) {
 992                                 ad->speaker_status = EINA_FALSE;
 993                         }
 994
 995                         CALL_UI_DEBUG("Headset Status = %d", ad->headset_status);
 996                         CALL_UI_DEBUG("ad->view_top:[%d]", ad->view_top);
 997
 998                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
 999                             || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
1000                                 if (ad->view_st[ad->view_top] != NULL) {
1001                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
1002                                 }
1003                         }
1004
1005                 }
1006                 break;
1007
1008         case VC_ENGINE_MSG_EARJACK_STATUS_TO_UI:
1009                 {
1010                         vc_engine_earjack_status_type earjack_status = msg->earjack_status;
1011
1012                         CALL_UI_DEBUG("earjack Status = %d", earjack_status.bstatus);
1013                         CALL_UI_DEBUG("ad->view_top:[%d]", ad->view_top);
1014
1015                         if(earjack_status.bstatus == EINA_TRUE) {
1016                                 if (ad->ctxpopup_radio_group_eo != NULL )
1017                                         elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_EARJACK);
1018 #ifdef _NEW_SND_
1019 #else
1020                                 _vcui_engine_change_sound_path(VCUI_AUDIO_EARJACK);
1021 #endif
1022
1023                                 ad->speaker_status = EINA_FALSE;
1024                                 ad->headset_status = EINA_FALSE;
1025
1026                                 if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
1027                                         || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
1028                                         if (ad->view_st[ad->view_top] != NULL) {
1029                                                 ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
1030                                         }
1031                                 }
1032                         } else {
1033                                 if (_vcui_is_headset_conected() == EINA_TRUE) {
1034                                         if (ad->ctxpopup_radio_group_eo != NULL )
1035                                                 elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_HEADSET);
1036
1037 #ifdef _NEW_SND_
1038 #else
1039                                         _vcui_engine_change_sound_path(VCUI_AUDIO_HEADSET);
1040 #endif
1041
1042                                         ad->speaker_status = EINA_FALSE;
1043                                         ad->headset_status = EINA_TRUE;
1044
1045                                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
1046                                                 || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
1047                                                 if (ad->view_st[ad->view_top] != NULL) {
1048                                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
1049                                                 }
1050                                         }
1051                                 } else {
1052                                         if (ad->ctxpopup_radio_group_eo != NULL )
1053                                                 elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_EARJACK);
1054
1055 #ifdef _NEW_SND_
1056 #else
1057                                         _vcui_engine_change_sound_path(VCUI_AUDIO_EARJACK);
1058 #endif
1059
1060                                         ad->speaker_status = EINA_FALSE;
1061                                         ad->headset_status = EINA_FALSE;
1062
1063                                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
1064                                                 || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
1065                                                 if (ad->view_st[ad->view_top] != NULL) {
1066                                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
1067                                                 }
1068                                         }
1069                                 }
1070                         }
1071                 }
1072                 break;
1073
1074         case VC_ENGINE_MSG_ACTION_INCOM_FORCE_TO_UI:
1075                 {
1076                         call_data_t *recent_mo = _vcui_doc_get_recent_mo();
1077                         if (recent_mo != NULL && recent_mo->call_handle == NO_HANDLE) {
1078                                 _vcui_doc_remove_call_data_only_list(recent_mo);
1079                                 _vcui_doc_set_mo_recent(NULL);
1080                         }
1081
1082                 }
1083                 break;
1084
1085         case VC_ENGINE_MSG_MESSAGE_BOX_TO_UI:
1086                 {
1087                         _voicecall_dvc_control_lcd_state(VC_LCD_ON_UNLOCK);
1088
1089                         vc_engine_msg_box_type msg_box = msg->msg_box;
1090                         _vcui_view_popup_load(_(gszcall_error_msg[msg_box.string_id]), POPUP_TIMEOUT_LONG, EINA_TRUE);
1091                 }
1092                 break;
1093
1094         case VC_ENGINE_MSG_REDIAL_TO_UI:
1095                 {
1096                         CALL_UI_DEBUG("not used");
1097                 }
1098                 break;
1099
1100         case VC_ENGINE_MSG_CREATE_NEWVOICEFILE_TO_UI:
1101                 {
1102                         CALL_UI_DEBUG("not used");
1103                 }
1104
1105         default:
1106                 break;
1107         }
1108
1109         _vcui_doc_all_print(gszcall_callback_msg[event]);
1110
1111         CALL_UI_DEBUG("End..");
1112
1113 }