ui/src/vcui-application.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-app-window.h"
  20 #include "vcui-app-data.h"
  21 #include "vcui-document.h"
  22
  23 #include "vcui-view-dialing.h"
  24 #include "vcui-view-incoming-lock.h"
  25 #include "vcui-view-keypad.h"
  26 #include "vcui-view-single-call.h"
  27 #include "vcui-view-multi-call-split.h"
  28 #include "vcui-view-multi-call-conf.h"
  29 #include "vcui-view-multi-call-list.h"
  30 #include "vcui-view-callend.h"
  31 #include "vcui-view-quickpanel.h"
  32 #include "vcui-view-popup.h"
  33 #include <glib.h>
  34 #include <glib-2.0/glib.h>
  35 #include <dbus/dbus-glib.h>
  36 #include <notification.h>
  37 #ifdef SIGNAL_HANDLER
  38 #include <signal.h>
  39 #endif
  40 #include "appsvc.h"
  41 #include "voice-call-engine.h"
  42
  43 static vcui_app_call_data_t global_ad;
  44
  45 #ifdef SIGNAL_HANDLER
  46 #define VCUI_SIG_NUM 12
  47 static struct sigaction vcui_app_sigact;
  48 static struct sigaction vcui_app_sigoldact[VCUI_SIG_NUM];
  49 static int vcui_app_sig_to_handle[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGQUIT, SIGSEGV, SIGSYS, SIGTRAP, SIGXCPU, SIGXFSZ, SIGTERM, SIGPIPE };
  50 #endif
  51
  52 static gboolean g_avoid_multi_setup = EINA_FALSE;
  53 static Eina_Bool __vcui_avoid_multi_setup_timer_cb(void *data);
  54
  55 #define CALL_PKG_NAME "org.tizen.call"
  56 #define CISS_AUL_CMD "org.tizen.ciss"
  57 #define CISS_MODE_OPT "REQ"
  58 #define __VCUI_NOTIFICATION_CALL_GROUP_ID 1001
  59
  60 /* For Debug Information, Call Event name string constant */
  61 static char *gszcall_callback_msg[VC_ENGINE_MSG_MAX_TO_UI] = {
  62         "VC_ENGINE_MSG_INCOM_TO_UI",
  63         "VC_ENGINE_MSG_OUTGOING_TO_UI",
  64         "VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI",
  65         "VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI_TEST",
  66         "VC_ENGINE_MSG_OUTGOING_ALERT_TO_UI",
  67         "VC_ENGINE_MSG_CONNECTED_TO_UI",
  68         "VC_ENGINE_MSG_NORMAL_END_TO_UI",
  69         "VC_ENGINE_MSG_INCOM_END_TO_UI",
  70         "VC_ENGINE_MSG_REJECTED_END_TO_UI",
  71         "VC_ENGINE_MSG_OUTGOING_END_TO_UI",
  72         "VC_ENGINE_MSG_OUTGOING_END_SIGNAL_PLAY_TO_UI",
  73         "VC_ENGINE_MSG_OUTGOING_ABORTED_TO_UI",
  74         "VC_ENGINE_MSG_DTMF_ACK_TO_UI",
  75
  76         "VC_ENGINE_MSG_SS_HELD_TO_UI",
  77         "VC_ENGINE_MSG_SS_RETREIVED_TO_UI",
  78         "VC_ENGINE_MSG_SS_SWAP_TO_UI",
  79         "VC_ENGINE_MSG_SS_SETUP_CONF_TO_UI",
  80         "VC_ENGINE_MSG_SS_SPLIT_CONF_TO_UI",
  81         "VC_ENGINE_MSG_SS_TRANSFERRED_TO_UI",
  82         "VC_ENGINE_MSG_SS_CONNECT_LINE_IND_TO_UI",
  83
  84         "VC_ENGINE_MSG_IND_FORWARD_TO_UI",
  85         "VC_ENGINE_MSG_IND_ACTIVATE_TO_UI",
  86         "VC_ENGINE_MSG_IND_HOLD_TO_UI",
  87         "VC_ENGINE_MSG_IND_TRANSFER_TO_UI",
  88         "VC_ENGINE_MSG_IND_SETUPCONFERENCE_TO_UI",
  89         "VC_ENGINE_MSG_IND_BARRING_TO_UI",
  90         "VC_ENGINE_MSG_IND_WAITING_TO_UI",
  91         "VC_ENGINE_MSG_IND_CUGINFO_TO_UI",
  92         "VC_ENGINE_MSG_IND_SSNOTIFY_TO_UI",
  93         "VC_ENGINE_MSG_IND_CALLINGNAMEINFO_TO_UI",
  94         "VC_ENGINE_MSG_IND_REDIRECT_CNF_TO_UI",
  95         "VC_ENGINE_MSG_IND_ACTIVATECCBS_CNF_TO_UI",
  96         "VC_ENGINE_MSG_IND_ACTIVATECCBS_USERINFO_TO_UI",
  97         "VC_ENGINE_MSG_IND_AOC_TO_UI",
  98
  99         "VC_ENGINE_MSG_ERROR_OCCURED_TO_UI",
 100
 101         "VC_ENGINE_MSG_ACTION_INCOM_FORCE_TO_UI",
 102         "VC_ENGINE_MSG_ACTION_SAT_REQUEST_TO_UI",
 103         "VC_ENGINE_MSG_ACTION_SAT_RESPONSE_TO_UI",
 104         "VC_ENGINE_MSG_ACTION_CALL_END_HELD_RETREIVED_TO_UI",
 105         "VC_ENGINE_MSG_ACTION_NO_ACTIVE_TASK_TO_UI",
 106
 107         "VC_ENGINE_MSG_GET_VOLUME_RESP_TO_UI",
 108         "VC_ENGINE_MSG_SET_VOLUME_FROM_BT_TO_UI",
 109         "VC_ENGINE_MSG_HEADSET_STATUS_TO_UI",
 110         "VC_ENGINE_MSG_EARJACK_STATUS_TO_UI",
 111
 112         "VC_ENGINE_MSG_ACCEPT_CHOICE_BOX_TO_UI",
 113         "VC_ENGINE_MSG_MESSAGE_BOX_TO_UI",
 114
 115         "VC_ENGINE_MSG_REDIAL_TO_UI",
 116         "VC_ENGINE_MSG_CREATE_NEWVOICEFILE_TO_UI",
 117 };
 118
 119 static char *gszcall_error_msg[IDS_CALL_MAX] = {
 120         "IDS_CALL_POP_CALL_IS_DIVERTED",
 121         "IDS_CALL_POP_CALLFAILED",
 122         "IDS_CALL_POP_CALLING_EMERG_ONLY",
 123         "IDS_CALL_POP_CALLNOTCALLOWED",
 124         "IDS_CALL_POP_CAUSE_WRONG_NUMBER",
 125         "IDS_CALL_POP_CHANGEOFFLINEMODETOCALL",
 126         "IDS_CALL_POP_DTMFSENDING_FAIL",
 127         "IDS_CALL_POP_FDNCALLONLY",
 128         "IDS_CALL_POP_HOLD_FAILED",
 129         "IDS_CALL_POP_HOLD_NOT_SUPPORTED",
 130         "IDS_CALL_POP_INCOMPLETE",
 131         "IDS_CALL_POP_JOIN_FAILED",
 132         "IDS_CALL_POP_JOIN_NOT_SUPPORTED",
 133         "IDS_CALL_POP_OPERATION_REFUSED",
 134         "IDS_CALL_POP_PHONE_NOT_INITIALISED",
 135         "IDS_CALL_POP_REJECTED",
 136         "IDS_CALL_POP_SENDING",
 137         "IDS_CALL_POP_SOS_CALL_ONLY_IN_NO_SIM_MODE",
 138         "IDS_CALL_POP_SPLIT_FAILED",
 139         "IDS_CALL_POP_SPLIT_NOT_SUPPORTED",
 140         "IDS_CALL_POP_SWAP_FAILED",
 141         "IDS_CALL_POP_SWAP_NOT_SUPPORTED",
 142         "IDS_CALL_POP_TRANSFER_FAILED",
 143         "IDS_CALL_POP_TRANSFER_NOT_SUPPORTED",
 144         "IDS_CALL_POP_UNABLE_TO_RETRIEVE",
 145         "IDS_CALL_POP_UNAVAILABLE",
 146         "IDS_CALL_POP_UNHOLD_NOT_SUPPORTED",
 147         "IDS_CALL_POP_VOICE_CALL_IS_NOT_ALLOWED_DURING_VIDEO_CALL",
 148         "IDS_CALL_POP_WAITING_ACTIVE",
 149         "IDS_CALL_BODY_CALLENDED",
 150         "Invalid DTMF",
 151         "Sent"
 152 };
 153
 154 static int __vcui_launch_ciss(const char *number);
 155 static void __vcui_cache_flush_set(Evas *e);
 156 static void __vcui_init_view_register_function(vcui_app_call_data_t *app_data, vcui_app_call_view_id_t view_id, voice_call_view_data_t *(*view_new) ());
 157 static int __vcui_app_create(void *data);
 158 static int __vcui_app_pause(void *data);
 159 static int __vcui_app_reset(bundle *kb, void *data);
 160 static int __vcui_app_resume(void *data);
 161 static int __vcui_app_terminate(void *data);
 162 static void __vcui_fade_out_cb_routine(void);
 163 static int __vcui_lang_changed_cb(void *data);
 164 static int __vcui_low_mem_cb(void *data);
 165 static int __vcui_low_bat_cb(void *data);
 166 static int __vcui_rotate_cb(enum appcore_rm m, void *data);
 167 static void __vcui_init(vcui_app_call_data_t *ad);
 168 static void __vcui_app_callback(int event, void *pdata, void *puser_data);
 169
 170 #ifdef SIGNAL_HANDLER
 171 /**
 172 * This function serves as the signal handler function for the SIGSEGV Signal
 173 *
 174 * @return               nothing
 175 * @param[in]            signal_no               Signal Number
 176 * @param[in]            signal_info     Information associated with the generated signal
 177 * @param[in]            signal_context  Signal Context Info
 178 */
 179 static void __vcui_exit_handler(void)
 180 {
 181         printf("\n __vcui_app_exit_handler\n");
 182         /*syslog (LOG_INFO, "[VOICE-CALL] __vcui_app_exit_handler\n"); */
 183 }
 184
 185 /**
 186 * This function serves as the signal handler function for the SIGSEGV Signal
 187 *
 188 * @return               nothing
 189 * @param[in]            signal_no               Signal Number
 190 * @param[in]            signal_info     Information associated with the generated signal
 191 * @param[in]            signal_context  Signal Context Info
 192 */
 193 static void __vcui_sigsegv_handler(int signal_no)
 194 {
 195         int i = 0;
 196
 197         CALL_UI_DEBUG("SISEGV Received, Signal Number: :%d \n", signal_no);
 198
 199         vcall_engine_force_reset();
 200         __vcui_fade_out_cb_routine();
 201
 202         for (i = 0; i < VCUI_SIG_NUM; i++) {
 203                 sigaction(vcui_app_sig_to_handle[i], &(vcui_app_sigoldact[i]), NULL);
 204         }
 205
 206         raise(signal_no);       /*raise signal intentionally (pass the same signal) */
 207 }
 208
 209 /**
 210 * This function registers a user space signal handler for the signal SIGSEGV (Signal #11)
 211 *
 212 * @return               nothing
 213 */
 214 static void __vcui_register_sigsegv_handler()
 215 {
 216         CALL_UI_DEBUG("..");
 217
 218         int i = 0;
 219         vcui_app_sigact.sa_flags = SA_NOCLDSTOP;
 220         vcui_app_sigact.sa_handler = (void *)__vcui_sigsegv_handler;
 221         sigemptyset(&vcui_app_sigact.sa_mask);
 222
 223         for (; i < VCUI_SIG_NUM; i++) {
 224                 sigaction(vcui_app_sig_to_handle[i], &vcui_app_sigact, &(vcui_app_sigoldact[i]));
 225         }
 226
 227 }
 228 #endif
 229
 230 static int __vcui_launch_ciss(const char *number)
 231 {
 232         bundle *kb;
 233
 234         CALL_UI_DEBUG("number(%s)");
 235         kb = bundle_create();
 236         bundle_add(kb, "CISS_LAUNCHING_MODE", CISS_MODE_OPT);
 237         bundle_add(kb, "CISS_REQ_STRING", number);
 238         aul_launch_app(CISS_AUL_CMD, kb);
 239         bundle_free(kb);
 240         return VC_NO_ERROR;
 241 }
 242
 243 static int __vcui_app_create(void *data)
 244 {
 245         CALL_UI_DEBUG("__vcui_app_create()..");
 246         CALL_UI_KPI("__vcui_app_create start");
 247         vcui_app_call_data_t *ad = data;
 248
 249         elm_theme_extension_add(NULL, CALL_THEME);
 250
 251         CALL_UI_KPI("_vcui_app_win_create_main start");
 252         ad->win_main = (Evas_Object *)_vcui_app_win_create_main(ad, PACKAGE);
 253         CALL_UI_KPI("_vcui_app_win_create_main done");
 254         if (ad->win_main == NULL) {
 255                 CALL_UI_DEBUG("ERROR");
 256                 return VC_ERROR;
 257         }
 258
 259         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 260
 261         __vcui_hide_main_ui_set_flag();
 262
 263         ad->evas = evas_object_evas_get(ad->win_main);
 264         ad->scale_factor = elm_config_scale_get();
 265
 266         __vcui_cache_flush_set(ad->evas);
 267
 268         ecore_init();
 269         ecore_x_init(NULL);
 270         _vcui_app_win_key_grab(ad);
 271
 272         _vcui_view_common_timer_text_init();
 273
 274         _vcui_app_win_set_noti_type(EINA_TRUE);
 275
 276         /* add system event callback */
 277         appcore_set_event_callback(APPCORE_EVENT_LANG_CHANGE, __vcui_lang_changed_cb, ad);
 278         appcore_set_event_callback(APPCORE_EVENT_LOW_MEMORY, __vcui_low_mem_cb, NULL);
 279         appcore_set_event_callback(APPCORE_EVENT_LOW_BATTERY, __vcui_low_bat_cb, NULL);
 280
 281         CALL_UI_KPI("appcore_set_rotation_cb start");
 282         appcore_set_rotation_cb(__vcui_rotate_cb, ad);
 283         CALL_UI_KPI("appcore_set_rotation_cb done");
 284
 285 #ifdef SIGNAL_HANDLER
 286         __vcui_register_sigsegv_handler();
 287         atexit(__vcui_exit_handler);
 288 #endif
 289
 290         /*
 291         ** Requested by Inpyo Kang
 292         ** This is temp fix for email UG bs proglem.. must be removed later.
 293         */
 294         elm_config_preferred_engine_set("opengl_x11");
 295
 296         CALL_UI_KPI("__vcui_app_create done");
 297         return VC_NO_ERROR;
 298 }
 299
 300 static int __vcui_app_pause(void *data)
 301 {
 302         CALL_UI_DEBUG("__vcui_app_pause()..");
 303
 304         return VC_NO_ERROR;
 305 }
 306
 307 static int __vcui_app_reset(bundle *kb, void *data)
 308 {
 309 /*
 310 #aul_test launch org.tizen.call launch-type "MO" number "01030011234"
 311 #aul_test launch org.tizen.call launch-type "MT" number "01030011234" handle "1" clicause "1" fwded "1" activeline "1"
 312 #aul_test open_content "01030011234"  ( /opt/share/miregex/phonenum.uri)
 313 */
 314         CALL_UI_DEBUG("__vcui_app_reset()..");
 315         CALL_UI_KPI("__vcui_app_reset start");
 316         vcui_app_call_data_t *ad = (vcui_app_call_data_t *)data;
 317
 318         const char *launch_type = NULL;
 319         const char *mime_type = NULL;
 320         const char *tmp = NULL;
 321         const char *uri_bundle = NULL;
 322         char *telnum = NULL;
 323
 324 #ifdef _RESET_OPEN_APP_
 325         {
 326                 launch_type = bundle_get_val(kb, "__AUL_CMD__");
 327                 if (launch_type != NULL) {
 328                         CALL_UI_DEBUG("launch type: [%s]", launch_type);
 329                         if (!strncmp(launch_type, "OPEN_APP", 8)) {
 330                                 elm_win_raise(ad->win_main);
 331                                 return;
 332                         }
 333                 }
 334         }
 335 #endif
 336
 337         /* mime content based AUL */
 338         mime_type = bundle_get_val(kb, AUL_K_MIME_TYPE);
 339         if (mime_type != NULL) {
 340                 CALL_UI_DEBUG("mime_type: [%s]", mime_type);
 341                 if (strncmp(mime_type, "phonenum.uri", 12) == 0 || strncmp(mime_type, "tel.uri", 7) == 0) {
 342                         tmp = bundle_get_val(kb, AUL_K_MIME_CONTENT);
 343                         if (tmp == NULL) {
 344                                 CALL_UI_DEBUG("bundle val is NULL");
 345                                 elm_exit();
 346                                 return VC_NO_ERROR;
 347                         }
 348
 349                         CALL_UI_DEBUG("AUL_K_MIME_CONTENT: [%s]", tmp);
 350                         if (strncmp(tmp, "tel:", 4) == 0) {
 351                                 telnum = (char *)tmp + 4;
 352                         } else {
 353                                 telnum = (char *)tmp;
 354                         }
 355
 356                         CALL_UI_DEBUG("number: [%s]", telnum);
 357
 358                         vcui_call_mo_data_t call_data;
 359                         memset(&call_data, 0, sizeof(call_data));
 360                         snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", telnum);
 361                         vcall_engine_process_normal_call(call_data.call_number, call_data.ct_index, EINA_FALSE);
 362
 363                         return VC_NO_ERROR;
 364                 } else {
 365                         CALL_UI_DEBUG("wrong mime type!!");
 366                         elm_exit();
 367                         return VC_NO_ERROR;
 368                 }
 369         }
 370
 371         uri_bundle = (const char *)appsvc_get_uri(kb);
 372         if (uri_bundle != NULL) {
 373                 CALL_UI_DEBUG("tmp: [%s]", uri_bundle);
 374                 if ((strncmp(uri_bundle, "tel:MT", 6) == 0)) {
 375                         CALL_UI_DEBUG("It is incoming call type");
 376                 } else if (strncmp(uri_bundle, "tel:", 4) == 0) {
 377                         telnum = (char *)uri_bundle + 4;
 378                         CALL_UI_DEBUG("number: [%s]", telnum);
 379
 380                         tmp = (char *)appsvc_get_data(kb, "calltype");
 381
 382                         if (tmp) {
 383                                 CALL_UI_DEBUG("calltype: [%s]", tmp);
 384                                 if (!strncmp(tmp, "EMERGENCY", 9)) {
 385                                         vcui_call_ecc_data_t call_data;
 386                                         memset(&call_data, 0, sizeof(call_data));
 387                                         snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", telnum);
 388                                         vcall_engine_process_emergency_call(call_data.call_number);
 389                                 } else {
 390                                         CALL_UI_DEBUG("wrong calltype!");
 391                                         elm_exit();
 392                                         return VC_ERROR;
 393                                 }
 394                         } else {
 395                                 vcui_call_mo_data_t call_data;
 396                                 memset(&call_data, 0, sizeof(call_data));
 397                                 snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", telnum);
 398
 399                                 tmp = (char *)appsvc_get_data(kb, "ctindex");
 400                                 if (tmp) {
 401                                         CALL_UI_DEBUG("ctindex: [%s]", tmp);
 402                                         call_data.ct_index = atoi(tmp);
 403                                 } else {
 404                                         CALL_UI_DEBUG("bundle val is NULL");
 405                                         call_data.ct_index = -1;
 406                                 }
 407
 408                                 if ((vcall_engine_check_incall_ss_string(call_data.call_number) == EINA_TRUE) && (_vcui_doc_get_all_call_data_count() >= 1)) {
 409                                         vcall_engine_process_incall_ss(call_data.call_number);
 410                                         _vcui_view_auto_change();
 411                                 } else if (vcall_engine_check_ss_string(call_data.call_number) == EINA_TRUE) {
 412                                         __vcui_launch_ciss(call_data.call_number);
 413                                         if (_vcui_doc_get_all_call_data_count() == 0)
 414                                                 elm_exit();
 415                                         return VC_NO_ERROR;
 416                                 } else {
 417                                         vcall_engine_process_normal_call(call_data.call_number, call_data.ct_index, EINA_FALSE);
 418                                 }
 419                         }
 420
 421                         return VC_NO_ERROR;
 422                 } else {
 423                         CALL_UI_DEBUG("wrong type!");
 424                         elm_exit();
 425                         return VC_NO_ERROR;
 426                 }
 427         }
 428
 429         /* AUL */
 430         launch_type = bundle_get_val(kb, "launch-type");
 431         if (launch_type != NULL) {
 432                 CALL_UI_DEBUG("launch type: [%s]", launch_type);
 433                 if (!strncmp(launch_type, "MO", 2)) {
 434
 435                         if (g_avoid_multi_setup == EINA_TRUE) {
 436                                 CALL_UI_DEBUG("Avoid multi touch setup");
 437                                 return VC_NO_ERROR;
 438                         }
 439
 440                         ecore_timer_add(3.5, __vcui_avoid_multi_setup_timer_cb, ad);
 441                         g_avoid_multi_setup = EINA_TRUE;
 442
 443                         vcui_call_mo_data_t call_data;
 444                         memset(&call_data, 0, sizeof(call_data));
 445
 446                         tmp = bundle_get_val(kb, "number");
 447                         if (tmp) {
 448                                 CALL_UI_DEBUG("number: [%s]", tmp);
 449                         } else {
 450                                 CALL_UI_DEBUG("bundle val is NULL");
 451                                 elm_exit();
 452                                 return VC_NO_ERROR;
 453                         }
 454                         snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", tmp);
 455
 456                         tmp = bundle_get_val(kb, "ctindex");
 457                         if (tmp) {
 458                                 CALL_UI_DEBUG("ctindex: [%s]", tmp);
 459                                 call_data.ct_index = atoi(tmp);
 460                         } else {
 461                                 CALL_UI_DEBUG("bundle val is NULL");
 462                                 call_data.ct_index = -1;
 463                         }
 464
 465                         if ((vcall_engine_check_incall_ss_string(call_data.call_number) == EINA_TRUE) && (_vcui_doc_get_all_call_data_count() >= 1)) {
 466                                 vcall_engine_process_incall_ss(call_data.call_number);
 467                                 _vcui_view_auto_change();
 468                         } else if (vcall_engine_check_ss_string(call_data.call_number) == EINA_TRUE) {
 469                                 __vcui_launch_ciss(call_data.call_number);
 470                                 if (_vcui_doc_get_all_call_data_count() == 0)
 471                                         elm_exit();
 472                                 return VC_NO_ERROR;
 473                         } else {
 474                                 vcall_engine_process_normal_call(call_data.call_number, call_data.ct_index, EINA_FALSE);
 475                         }
 476                 } else if (!strncmp(launch_type, "MT", 2)) {
 477                         vcui_call_mt_data_t call_data;
 478                         memset(&call_data, 0, sizeof(call_data));
 479
 480                         tmp = bundle_get_val(kb, "handle");
 481                         if (tmp) {
 482                                 CALL_UI_DEBUG("handle: [%s]", tmp);
 483                                 call_data.call_handle = atoi(tmp);
 484                         } else {
 485                                 CALL_UI_DEBUG("bundle val is NULL");
 486                                 elm_exit();
 487                                 return VC_NO_ERROR;
 488                         }
 489
 490                         tmp = bundle_get_val(kb, "calltype");
 491                         if (tmp) {
 492                                 CALL_UI_DEBUG("calltype: [%s]", tmp);
 493                                 call_data.call_type = atoi(tmp);
 494                         } else {
 495                                 CALL_UI_DEBUG("calltype is NULL but NOT mendatory");
 496                                 call_data.call_type = 0;
 497                         }
 498
 499                         tmp = bundle_get_val(kb, "cliindicator");
 500                         if (tmp) {
 501                                 CALL_UI_DEBUG("cliindicator: [%s]", tmp);
 502                                 call_data.cli_presentation_indicator = atoi(tmp);
 503                         } else {
 504                                 CALL_UI_DEBUG("cliindicator is NULL but NOT mendatory");
 505                                 call_data.cli_presentation_indicator = 0;
 506                         }
 507
 508                         tmp = bundle_get_val(kb, "number");
 509                         if (tmp) {
 510                                 CALL_UI_DEBUG("number: [%s]", tmp);
 511                                 vcall_engine_util_strcpy(call_data.call_num, VC_PHONE_NUMBER_LENGTH_MAX, tmp);
 512                         } else {
 513                                 CALL_UI_DEBUG("bundle val is NULL");
 514                                 /*return VC_NO_ERROR; *//*check clir mt call. */
 515                         }
 516
 517                         tmp = bundle_get_val(kb, "name_mode");
 518                         if (tmp) {
 519                                 CALL_UI_DEBUG("name_mode: [%s]", tmp);
 520                                 call_data.calling_name_mode = atoi(tmp);
 521                         } else {
 522                                 CALL_UI_DEBUG("name_mode is NULL but NOT mendatory");
 523                                 call_data.calling_name_mode = -1;
 524                         }
 525
 526                         tmp = bundle_get_val(kb, "name");
 527                         if (tmp) {
 528                                 CALL_UI_DEBUG("name: [%s]", tmp);
 529                                 vcall_engine_util_strcpy(call_data.calling_name, VC_PHONE_NAME_LENGTH_MAX, tmp);
 530                         } else {
 531                                 CALL_UI_DEBUG("bundle val is NULL but NOT mendatory");
 532                         }
 533
 534                         tmp = bundle_get_val(kb, "rdnumber");
 535                         if (tmp) {
 536                                 CALL_UI_DEBUG("rdnumber: [%s]", tmp);
 537                                 vcall_engine_util_strcpy(call_data.redirected_number, VC_PHONE_NUMBER_LENGTH_MAX, tmp);
 538                         } else {
 539                                 CALL_UI_DEBUG("bundle val is NULL but NOT mendatory");
 540                         }
 541
 542                         tmp = bundle_get_val(kb, "rdsubaddress");
 543                         if (tmp) {
 544                                 CALL_UI_DEBUG("rdnumber: [%s]", tmp);
 545                                 vcall_engine_util_strcpy(call_data.redirected_sub_address, VC_PHONE_SUBADDRESS_LENGTH_MAX, tmp);
 546                         } else {
 547                                 CALL_UI_DEBUG("bundle val is NULL but NOT mendatory");
 548                         }
 549
 550                         tmp = bundle_get_val(kb, "clicause");
 551                         if (tmp) {
 552                                 CALL_UI_DEBUG("clicause: [%s]", tmp);
 553                                 call_data.cli_cause = atoi(tmp);
 554                         } else {
 555                                 CALL_UI_DEBUG("bundle val is NULL");
 556                                 elm_exit();
 557                                 return VC_NO_ERROR;
 558                         }
 559
 560                         tmp = bundle_get_val(kb, "fwded");
 561                         if (tmp) {
 562                                 CALL_UI_DEBUG("fwded: [%s]", tmp);
 563                                 call_data.bfwded = atoi(tmp);
 564                         } else {
 565                                 CALL_UI_DEBUG("bundle val is NULL");
 566                                 elm_exit();
 567                                 return VC_NO_ERROR;
 568                         }
 569
 570                         tmp = bundle_get_val(kb, "activeline");
 571                         if (tmp) {
 572                                 CALL_UI_DEBUG("activeline: [%s]", tmp);
 573                                 call_data.active_line = atoi(tmp);
 574                         } else {
 575                                 CALL_UI_DEBUG("bundle val is NULL");
 576                                 elm_exit();
 577                                 return VC_NO_ERROR;
 578                         }
 579
 580                         vcall_engine_incoming_info_t mtcall_info;
 581
 582                         mtcall_info.call_handle = call_data.call_handle;
 583                         mtcall_info.call_type = call_data.call_type;
 584                         mtcall_info.cli_presentation_indicator = call_data.cli_presentation_indicator;
 585                         vcall_engine_util_strcpy(mtcall_info.call_num, sizeof(mtcall_info.call_num), call_data.call_num);
 586                         mtcall_info.calling_name_mode = call_data.calling_name_mode;
 587                         vcall_engine_util_strcpy(mtcall_info.calling_name, sizeof(mtcall_info.calling_name), call_data.calling_name);
 588                         vcall_engine_util_strcpy(mtcall_info.redirected_number, sizeof(mtcall_info.redirected_number), call_data.redirected_number);
 589                         vcall_engine_util_strcpy(mtcall_info.redirected_sub_address, sizeof(mtcall_info.redirected_sub_address), call_data.redirected_sub_address);
 590                         mtcall_info.cli_cause = call_data.cli_cause;
 591                         mtcall_info.bfwded = call_data.bfwded;
 592                         mtcall_info.active_line = call_data.active_line;
 593
 594                         vcall_engine_process_incoming_call(&mtcall_info);
 595                 } else if (!strncmp(launch_type, "EMERGENCY", 9)) {
 596                         vcui_call_ecc_data_t call_data;
 597                         memset(&call_data, 0, sizeof(call_data));
 598
 599                         tmp = bundle_get_val(kb, "number");
 600                         if (tmp) {
 601                                 CALL_UI_DEBUG("number: [%s]", tmp);
 602                         } else {
 603                                 CALL_UI_DEBUG("bundle val is NULL");
 604                         }
 605                         snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", tmp);
 606                         vcall_engine_process_emergency_call(call_data.call_number);
 607                 } else if (!strncmp(launch_type, "SATSETUPCALL", 12)) {
 608                         vcui_call_sat_data_t sat_setup_call_info;
 609                         memset(&sat_setup_call_info, 0, sizeof(sat_setup_call_info));
 610
 611                         tmp = bundle_get_val(kb, "cmd_id");
 612                         if (tmp) {
 613                                 CALL_UI_DEBUG("cmd_id: [%s]", tmp);
 614                                 sat_setup_call_info.command_id = atoi(tmp);
 615                         } else {
 616                                 CALL_UI_DEBUG("bundle val is NULL");
 617                                 elm_exit();
 618                                 return VC_NO_ERROR;
 619                         }
 620
 621                         tmp = bundle_get_val(kb, "cmd_qual");
 622                         if (tmp) {
 623                                 CALL_UI_DEBUG("cmd_qual: [%s]", tmp);
 624                                 sat_setup_call_info.command_qualifier = atoi(tmp);
 625                         } else {
 626                                 CALL_UI_DEBUG("bundle val is NULL");
 627                                 elm_exit();
 628                                 return VC_NO_ERROR;
 629                         }
 630
 631                         tmp = bundle_get_val(kb, "disp_text");
 632                         if (tmp) {
 633                                 CALL_UI_DEBUG("disp_text: [%s]", tmp);
 634                                 vcall_engine_util_strcpy(sat_setup_call_info.disp_text, sizeof(sat_setup_call_info.disp_text), tmp);
 635                         } else {
 636                                 CALL_UI_DEBUG("bundle val is NULL");
 637                                 /*elm_exit();
 638                                    return VC_NO_ERROR; */
 639                         }
 640
 641                         tmp = bundle_get_val(kb, "call_num");
 642                         if (tmp) {
 643                                 CALL_UI_DEBUG("call_num: [%s]", tmp);
 644                                 vcall_engine_util_strcpy(sat_setup_call_info.call_num, sizeof(sat_setup_call_info.call_num), tmp);
 645                         } else {
 646                                 CALL_UI_DEBUG("bundle val is NULL");
 647                                 elm_exit();
 648                                 return VC_NO_ERROR;
 649                         }
 650
 651                         tmp = bundle_get_val(kb, "dur");
 652                         if (tmp) {
 653                                 CALL_UI_DEBUG("dur: [%s]", tmp);
 654                                 sat_setup_call_info.duration = atoi(tmp);
 655                         } else {
 656                                 CALL_UI_DEBUG("bundle val is NULL");
 657                                 elm_exit();
 658                                 return VC_NO_ERROR;
 659                         }
 660
 661                         vcall_engine_sat_setup_call_info_t sat_setup_data;
 662                         memset(&sat_setup_data, 0, sizeof(sat_setup_data));
 663                         sat_setup_data.command_id = sat_setup_call_info.command_id;
 664                         sat_setup_data.command_qualifier = sat_setup_call_info.command_qualifier;
 665                         sat_setup_data.duration = sat_setup_call_info.duration;
 666                         memcpy(sat_setup_data.disp_text, sat_setup_call_info.disp_text, sizeof(sat_setup_data.disp_text));
 667                         memcpy(sat_setup_data.call_num, sat_setup_call_info.call_num, VC_PHONE_NUMBER_LENGTH_MAX);
 668
 669                         vcall_engine_process_sat_setup_call(&sat_setup_data);
 670                 } else if (!strncmp(launch_type, "ECCTEST", 7)) {
 671                         vcui_call_ecc_data_t call_data;
 672                         memset(&call_data, 0, sizeof(call_data));
 673                         vcall_engine_process_emergency_call_test(call_data.call_number);
 674                 } else if (!strncmp(launch_type, "DOWNLOADCALL", 12)) {
 675                         vcui_call_mo_data_t call_data;
 676                         memset(&call_data, 0, sizeof(call_data));
 677
 678                         tmp = bundle_get_val(kb, "number");
 679                         if (tmp) {
 680                                 CALL_UI_DEBUG("number: [%s]", tmp);
 681                         } else {
 682                                 CALL_UI_DEBUG("bundle val is NULL");
 683                         }
 684
 685                         if (tmp != NULL) {
 686                                 snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", tmp);
 687                         } else {
 688                                 snprintf(call_data.call_number, sizeof(call_data.call_number), "%s", "116");
 689                         }
 690                         vcall_engine_util_strcpy(call_data.call_number, sizeof(call_data.call_number), tmp);
 691                         vcall_engine_process_normal_call(call_data.call_number, call_data.ct_index, EINA_TRUE);
 692                 } else if (!strncmp(launch_type, "CALL_COMMAND", 12)) {
 693                         vcui_call_mo_data_t call_data;
 694                         memset(&call_data, 0, sizeof(call_data));
 695
 696                         tmp = bundle_get_val(kb, "value");
 697                         if (tmp) {
 698                                 CALL_UI_DEBUG("number: [%s]", tmp);
 699                         } else {
 700                                 CALL_UI_DEBUG("bundle val is NULL");
 701                         }
 702
 703                         if (!strncmp(tmp, "REJECT_MT", 9)) {
 704                                 vcall_engine_reject_call();
 705                         }       /* If need to add more command, add here. */
 706                 } else {
 707                         CALL_UI_DEBUG("unknown launch type");
 708                 }
 709                 CALL_UI_KPI("__vcui_app_reset done");
 710                 return VC_NO_ERROR;
 711         }
 712
 713         CALL_UI_DEBUG("bundle data is wrong!!");
 714         elm_exit();
 715         return VC_NO_ERROR;
 716 }
 717
 718 static int __vcui_app_resume(void *data)
 719 {
 720         CALL_UI_DEBUG("__vcui_app_resume()..");
 721
 722         return VC_NO_ERROR;
 723 }
 724
 725 static int __vcui_app_terminate(void *data)
 726 {
 727         CALL_UI_DEBUG("__vcui_app_terminate()..");
 728
 729         if (_vcui_doc_get_all_call_data_count() >= 1) {
 730                 CALL_UI_DEBUG("WARNING!! call exists. abnormal terminate!!");
 731                 vcall_engine_release_call_by_type(VCALL_ENGINE_RELEASE_ALL_CALLS);
 732                 vcall_engine_set_to_default();
 733         }
 734
 735         __vcui_fade_out_cb_routine();
 736         return VC_NO_ERROR;
 737 }
 738
 739 static void __vcui_cache_flush_set(Evas *e)
 740 {
 741 #ifdef _CACHE_FLUSH_
 742         evas_image_cache_set(e, 4096 * 1024);
 743         evas_font_cache_set(e, 512 * 1024);
 744
 745         edje_file_cache_set(0);
 746         edje_collection_cache_set(0);
 747 #endif
 748 }
 749
 750 static void __vcui_init_view_register_function(vcui_app_call_data_t *app_data, vcui_app_call_view_id_t view_id, voice_call_view_data_t *(*view_new) ())
 751 {
 752         app_data->func_new[view_id] = view_new;
 753 }
 754
 755 void _vcui_response_volume(int vol_alert_type, int vol_level)
 756 {
 757         vcui_app_call_data_t *ad = _vcui_get_app_data();
 758
 759         if (vol_alert_type == VCUI_VOL_VOICE) {
 760                 ad->voice_vol_val = vol_level;
 761                 _vcui_set_volume(ad->vol_key_status);
 762         } else if (vol_alert_type == VCUI_VOL_HEADSET) {
 763                 ad->bt_vol_val = vol_level;
 764                 _vcui_set_volume(ad->vol_key_status);
 765         } else {
 766                 CALL_UI_DEBUG("ERROR");
 767         }
 768 }
 769
 770 void _vcui_set_volume(int key_status)
 771 {
 772         vcui_app_call_data_t *ad = _vcui_get_app_data();
 773
 774         if (_vcui_doc_get_all_call_data_count() == 0) {
 775                 CALL_UI_DEBUG("ignore it");
 776                 return;
 777         }
 778
 779         if (ad->view_st[ad->view_top]->type == VIEW_INCOMING_LOCK_VIEW) {
 780                 int err_code = 0;
 781                 int settings_sound_status = EINA_FALSE;
 782
 783                 err_code = vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &settings_sound_status);
 784                 if (settings_sound_status == EINA_FALSE) {
 785                         CALL_UI_DEBUG("ringtone vol is ignored in sound off status.");
 786                         return;
 787                 }
 788
 789                 if (ad->bmute_ringtone == EINA_TRUE) {
 790                         CALL_UI_DEBUG("during mute ringtone, vol will not changed");
 791                         return;
 792                 }
 793
 794                 if (ad->ringtone_val < RINGTONE_MIN) {
 795                         int vol_level = vcall_engine_get_volume_level(VCALL_ENGINE_VOL_TYPE_RINGTONE);
 796
 797                         if ((vol_level < RINGTONE_MIN) || (vol_level > RINGTONE_MAX)) {
 798                                 CALL_UI_DEBUG("ERROR : ringtone vol:[%d]", vol_level);
 799                                 return;
 800                         }
 801                         ad->ringtone_val = vol_level;
 802                 }
 803
 804                 CALL_UI_DEBUG("RINGTONE : Set Volume");
 805                 if (key_status == VAL_VOL_DOWN && ad->ringtone_val > RINGTONE_MIN) {
 806                         ad->ringtone_val--;
 807                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_RINGTONE, ad->ringtone_val);
 808                 } else if (key_status == VAL_VOL_UP && ad->ringtone_val < RINGTONE_MAX) {
 809                         ad->ringtone_val++;
 810                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_RINGTONE, ad->ringtone_val);
 811                 }
 812                 _vcui_view_popup_vol_ringtone(ad->ringtone_val);
 813         } else if (ad->headset_status == EINA_TRUE) {
 814                 if (ad->bt_vol_val < BT_VOL_MIN) {
 815                         CALL_UI_DEBUG("BT VOL : Get Volume");
 816                         ad->vol_key_status = key_status;
 817                         ad->bt_vol_val = vcall_engine_get_volume_level(VCALL_ENGINE_VOL_TYPE_HEADSET);
 818                         return;
 819                 }
 820
 821                 CALL_UI_DEBUG("BT VOL : Set Volume");
 822                 if (key_status == VAL_VOL_DOWN && ad->bt_vol_val > BT_VOL_MIN) {        /*Key Down */
 823                         ad->bt_vol_val--;
 824                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_HEADSET, ad->bt_vol_val);
 825                 } else if (key_status == VAL_VOL_UP && ad->bt_vol_val < BT_VOL_MAX) {   /*Key Up */
 826                         ad->bt_vol_val++;
 827                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_HEADSET, ad->bt_vol_val);
 828                 }
 829                 _vcui_view_popup_vol_bt(ad->bt_vol_val);
 830         } else {
 831                 CALL_UI_DEBUG("TAPI VOL : Get Volume");
 832                 ad->vol_key_status = key_status;
 833                 ad->voice_vol_val = vcall_engine_get_volume_level(VCALL_ENGINE_VOL_TYPE_VOICE);
 834
 835                 CALL_UI_DEBUG("TAPI VOL : Set Volume");
 836                 if (key_status == VAL_VOL_DOWN && ad->voice_vol_val > VOICE_VOL_MIN) {  /*Key Down */
 837                         ad->voice_vol_val--;
 838                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_VOICE, ad->voice_vol_val);
 839                 } else if (key_status == VAL_VOL_UP && ad->voice_vol_val < VOICE_VOL_MAX) {     /*Key Up */
 840                         ad->voice_vol_val++;
 841                         vcall_engine_set_volume_level(VCALL_ENGINE_VOL_TYPE_VOICE, ad->voice_vol_val);
 842                 }
 843                 _vcui_view_popup_vol_voice(ad->voice_vol_val);
 844         }
 845
 846 }
 847
 848 static void __vcui_fade_out_cb_routine()
 849 {
 850         CALL_UI_DEBUG("..");
 851         vcui_app_call_data_t *ad = _vcui_get_app_data();
 852
 853         if (ad->child_is == 1) {
 854                 /*system("killall dialer"); */
 855         }
 856         if (ad->disp && ad->win) {
 857                 utilx_ungrab_key(ad->disp, ad->win, KEY_VOLUMEUP);
 858                 utilx_ungrab_key(ad->disp, ad->win, KEY_VOLUMEDOWN);
 859                 utilx_ungrab_key(ad->disp, ad->win, KEY_SELECT);
 860         }
 861
 862         if (ad->focus_in) {
 863                 ecore_event_handler_del(ad->focus_in);
 864                 ad->focus_in = NULL;
 865         }
 866         if (ad->focus_out) {
 867                 ecore_event_handler_del(ad->focus_out);
 868                 ad->focus_out = NULL;
 869         }
 870
 871         _vcui_doc_remove_all_call_data();
 872         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
 873         _vcui_view_common_timer_destroy();
 874 }
 875
 876 static int __vcui_lang_changed_cb(void *data)
 877 {
 878         CALL_UI_DEBUG("..");
 879
 880         _vcui_view_auto_change();
 881         _vcui_view_quickpanel_change();
 882
 883         return VC_NO_ERROR;
 884 }
 885
 886 static int __vcui_low_mem_cb(void *data)
 887 {
 888         CALL_UI_DEBUG("..");
 889
 890         return VC_NO_ERROR;
 891 }
 892
 893 static int __vcui_low_bat_cb(void *data)
 894 {
 895         CALL_UI_DEBUG("..");
 896
 897         return VC_NO_ERROR;
 898 }
 899
 900 static int __vcui_get_rotate_angle(enum appcore_rm rotate_mode)
 901 {
 902         CALL_UI_DEBUG("..");
 903         int rotate_angle;
 904         if (APPCORE_RM_UNKNOWN == rotate_mode) {
 905                 appcore_get_rotation_state(&rotate_mode);
 906         }
 907
 908         switch (rotate_mode) {
 909         case APPCORE_RM_PORTRAIT_NORMAL:
 910                                         /**< Portrait mode */
 911                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_PORTRAIT_NORMAL");
 912                 rotate_angle = 0;
 913                 break;
 914         case APPCORE_RM_PORTRAIT_REVERSE:
 915                                          /**< Portrait upside down mode */
 916                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_PORTRAIT_REVERSE");
 917                 rotate_angle = 180;
 918                 break;
 919         case APPCORE_RM_LANDSCAPE_NORMAL:
 920                                          /**< Left handed landscape mode */
 921                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_LANDSCAPE_NORMAL");
 922                 rotate_angle = 270;
 923                 break;
 924         case APPCORE_RM_LANDSCAPE_REVERSE:
 925                                           /**< Right handed landscape mode */
 926                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_LANDSCAPE_REVERSE");
 927                 rotate_angle = 90;
 928                 break;
 929         default:
 930                 rotate_angle = -1;
 931                 break;
 932         }
 933
 934         return rotate_angle;
 935 }
 936
 937 static void __vcui_ug_handle_rotate_event(const int rotate_angle, void *data)
 938 {
 939         CALL_UI_DEBUG("..");
 940         vcui_app_call_data_t *ad = (vcui_app_call_data_t *)data;
 941
 942         switch (rotate_angle) {
 943         case 0:
 944                /**< Portrait mode */
 945                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_PORTRAIT_NORMAL");
 946                 ug_send_event(UG_EVENT_ROTATE_PORTRAIT);
 947                 break;
 948         case 180:
 949                  /**< Portrait upside down mode */
 950                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_PORTRAIT_REVERSE");
 951                 ug_send_event(UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN);
 952                 break;
 953         case 270:
 954                  /**< Left handed landscape mode */
 955                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_LANDSCAPE_NORMAL");
 956                 ug_send_event(UG_EVENT_ROTATE_LANDSCAPE);
 957                 break;
 958         case 90:
 959                 /**< Right handed landscape mode */
 960                 CALL_UI_DEBUG("rotate mode is APPCORE_RM_LANDSCAPE_REVERSE");
 961                 ug_send_event(UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN);
 962                 break;
 963         default:
 964                 break;
 965         }
 966         if ((rotate_angle >= 0)
 967                 && (ad->contact_ug == NULL)) {
 968                 elm_win_rotation_with_resize_set(ad->win_main, rotate_angle);
 969         }
 970 }
 971
 972 #ifdef  __LANDSCAPE_MODE_
 973 static Eina_Bool __vcui_handle_rotate_evnt_idle_cb(void *data)
 974 {
 975         CALL_UI_DEBUG("..");
 976         vcui_app_call_data_t *ad = (vcui_app_call_data_t *)data;
 977
 978         if (ad == NULL)
 979                 return EINA_FALSE;
 980
 981         CALL_UI_DEBUG("Rotate on ad->view_top[%d]", ad->view_top);
 982         _vcui_view_change(ad->view_top, 0, NULL, NULL);
 983         return ECORE_CALLBACK_CANCEL;
 984 }
 985
 986 static void __vcui_handle_rotate_event(const int rotate_angle, void *data)
 987 {
 988         CALL_UI_DEBUG("..");
 989         vcui_app_call_data_t *ad = (vcui_app_call_data_t *)data;
 990
 991         if (ad == NULL) {
 992                 CALL_UI_DEBUG("ad is NULL");
 993                 return;
 994         }
 995
 996         if (0 == rotate_angle || 180 == rotate_angle || 270 == rotate_angle || 90 == rotate_angle) {
 997                 ad->rotate_angle = rotate_angle;
 998                 ecore_idler_add(__vcui_handle_rotate_evnt_idle_cb, ad);
 999         }
1000         return;
1001 }
1002 #endif
1003
1004 static int __vcui_rotate_cb(enum appcore_rm rotate_mode, void *data)
1005 {
1006         CALL_UI_DEBUG("__vcui_rotate_cb()..");
1007         vcui_app_call_data_t *ad = _vcui_get_app_data();
1008         int rotate_angle;
1009         if (ad == NULL) {
1010                 CALL_UI_DEBUG("ad is NULL");
1011                 return VC_ERROR;
1012         }
1013
1014         rotate_angle = __vcui_get_rotate_angle(rotate_mode);
1015         CALL_UI_DEBUG("rotate_angle [%d]", rotate_angle);
1016         if (ad->contact_ug)
1017         {
1018                 __vcui_ug_handle_rotate_event(rotate_angle, ad);
1019         }
1020 #ifdef  __LANDSCAPE_MODE_
1021         else {
1022                 /* Implement the landscape implementation here */
1023                 __vcui_handle_rotate_event(rotate_angle, ad);
1024         }
1025 #endif
1026         return VC_NO_ERROR;
1027 }
1028
1029 static void __vcui_init(vcui_app_call_data_t *ad)
1030 {
1031         CALL_UI_KPI("g_type_init start");
1032         g_type_init();
1033         CALL_UI_KPI("g_type_init done");
1034         _vcui_doc_data_init();
1035         _vcui_view_common_init();
1036         vcall_engine_init((vcall_engine_app_cb) __vcui_app_callback, ad);
1037
1038         CALL_UI_KPI("__vcui_init_view_register_function for all views start");
1039         __vcui_init_view_register_function(ad, VIEW_DIALLING_VIEW, _vcui_view_dialing_new);
1040         __vcui_init_view_register_function(ad, VIEW_INCOMING_LOCK_VIEW, _vcui_view_incoming_lock_new);
1041         __vcui_init_view_register_function(ad, VIEW_INCALL_ONECALL_VIEW, _vc_ui_view_single_call_new);
1042         __vcui_init_view_register_function(ad, VIEW_INCALL_MULTICALL_SPLIT_VIEW, _vcui_view_multi_call_split_new);
1043         __vcui_init_view_register_function(ad, VIEW_INCALL_MULTICALL_CONF_VIEW, _vcui_view_multi_call_conf_new);
1044         __vcui_init_view_register_function(ad, VIEW_INCALL_MULTICALL_LIST_VIEW, _vcui_view_multi_call_list_new);
1045         __vcui_init_view_register_function(ad, VIEW_ENDCALL_VIEW, _vcui_view_callend_new);
1046         __vcui_init_view_register_function(ad, VIEW_QUICKPANEL_VIEW, _vcui_view_qp_new);
1047         CALL_UI_KPI("__vcui_init_view_register_function for all views done");
1048
1049         ad->view_top = -1;
1050         ad->view_before_top = -1;
1051         ad->headset_status = (int)_vcui_is_headset_conected();
1052         ad->speaker_status = EINA_FALSE;
1053         ad->mute_status = EINA_FALSE;
1054         ad->child_is = -1;
1055         ad->show_flag = WIN_HIDE;
1056         ad->ringtone_val = -1;
1057         ad->voice_vol_val = -1;
1058         ad->bt_vol_val = -1;
1059         ad->call_end_type = CALL_END_TYPE_NONE;
1060         ad->wbamr_status= EINA_FALSE;
1061 }
1062
1063 char *_vcui_get_endcause_string(int end_cause, char *data)
1064 {
1065         char *string_id = NULL;
1066         CALL_UI_DEBUG("end type : %d", end_cause);
1067         switch (end_cause) {
1068         case VC_ENGINE_ENDCAUSE_USER_UNAVAILABLE:
1069                 string_id = _("IDS_CALL_BODY_CALLED_PARTY_UNAVAILABLE");
1070                 break;
1071         case VC_ENGINE_ENDCAUSE_UNASSIGNED_NUMBER:
1072                 string_id = _("IDS_CALL_BODY_NUMBER_DOES_NOT_EXIST");
1073                 break;
1074         case VC_ENGINE_ENDCAUSE_USER_DOESNOT_RESPOND:
1075                 string_id = _("IDS_CALL_BODY_NO_ANSWER");
1076                 break;
1077         case VC_ENGINE_ENDCAUSE_CALL_DISCONNECTED:
1078                 string_id = _("IDS_CALL_BODY_DISCONNECTED");
1079                 break;
1080         case VC_ENGINE_ENDCAUSE_CALL_ENDED:
1081                 string_id = _("IDS_CALL_BODY_CALLENDED");
1082                 break;
1083         case VC_ENGINE_ENDCAUSE_CALL_SERVICE_NOT_ALLOWED:
1084                 string_id = _("IDS_CALL_POP_SERVICE_NOT_ALLOWED");
1085                 break;
1086         case VC_ENGINE_ENDCAUSE_CALL_BARRED:
1087                 string_id = _("IDS_CALL_POP_CALL_BARRED");
1088                 break;
1089         case VC_ENGINE_ENDCAUSE_NO_SERVICE:
1090                 string_id = _("IDS_CALL_POP_NOSERVICE");
1091                 break;
1092         case VC_ENGINE_ENDCAUSE_NW_BUSY:
1093                 string_id = _("IDS_CALL_POP_NETWORKBUSY");
1094                 break;
1095         case VC_ENGINE_ENDCAUSE_NW_FAILED:
1096                 string_id = _("IDS_CALL_POP_NETWORK_UNAVAILABLE");
1097                 break;
1098         case VC_ENGINE_ENDCAUSE_SERVICE_TEMP_UNAVAILABLE:
1099                 string_id = _("IDS_CALL_BODY_SERVICE_UNAVAILABLE");
1100                 break;
1101         case VC_ENGINE_ENDCAUSE_NO_ANSWER:
1102                 string_id = _("IDS_CALL_BODY_NO_ANSWER");
1103                 break;
1104         case VC_ENGINE_ENDCAUSE_NO_CREDIT:
1105                 string_id = _("IDS_CALL_POP_NOCREDITLEFT");
1106                 break;
1107         case VC_ENGINE_ENDCAUSE_REJECTED:
1108                 string_id = _("IDS_CALL_BODY_CALL_REJECTED");
1109                 break;
1110         case VC_ENGINE_ENDCAUSE_USER_BUSY:
1111                 string_id = _("IDS_CALL_POP_USER_BUSY");
1112                 break;
1113         case VC_ENGINE_ENDCAUSE_WRONG_GROUP:
1114                 string_id = _("IDS_CALL_POP_WRONG_GROUP");
1115                 break;
1116         case VC_ENGINE_ENDCAUSE_INVALID_NUMBER_FORMAT:
1117                 string_id = _("IDS_CALL_POP_CAUSE_WRONG_NUMBER");
1118                 break;
1119         case VC_ENGINE_ENDCAUSE_CALL_NOT_ALLOWED:
1120                 string_id = _("IDS_CALL_POP_CALLNOTCALLOWED");
1121                 break;
1122         case VC_ENGINE_ENDCAUSE_TAPI_ERROR:
1123                 string_id = _("IDS_CALL_POP_AEESYS_SYSTEMFAILUREERROR");
1124                 break;
1125         case VC_ENGINE_ENDCAUSE_CALL_FAILED:
1126                 string_id = _("IDS_CALL_POP_CALLFAILED");
1127                 break;
1128         case VC_ENGINE_ENDCAUSE_NUMBER_CHANGED:
1129                 string_id = _("IDS_CALL_BODY_NUMBER_CHANGED");
1130                 break;
1131         case VC_ENGINE_ENDCAUSE_IMEI_REJECTED:
1132                 string_id = _("IDS_CALL_POP_VERIFY_SIM_OR_INSERT_VALID_SIM");
1133                 break;
1134         case VC_ENGINE_ENDCAUSE_NO_USER_RESPONDING:     /**< User not responding */
1135         case VC_ENGINE_ENDCAUSE_USER_ALERTING_NO_ANSWER:        /**< User Alerting No Answer */
1136         default:
1137                 string_id = _("IDS_CALL_BODY_CALLENDED");
1138                 break;
1139         }
1140         vcall_engine_util_strcpy(data, VC_DATA_LENGTH_MAX, string_id);
1141         return data;
1142 }
1143
1144 void _vcui_cache_flush()
1145 {
1146 #ifdef _CACHE_FLUSH_
1147         vcui_app_call_data_t *ad = _vcui_get_app_data();
1148
1149         evas_font_cache_flush(ad->evas);
1150         evas_image_cache_flush(ad->evas);
1151
1152         edje_file_cache_flush();
1153         edje_collection_cache_flush();
1154
1155         evas_render_idle_flush(ad->evas);
1156 #endif
1157 }
1158
1159 int _vcui_is_idle_lock()
1160 {
1161         int lock_state;
1162         int ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &(lock_state));
1163         if (ret == -1) {
1164                 CALL_UI_DEBUG("Cannot get vconf key");
1165         }
1166
1167         if (lock_state == VCONFKEY_IDLE_LOCK)
1168                 return CALL_LOCK;
1169         else
1170                 return CALL_UNLOCK;
1171 }
1172
1173 unsigned long _vcui_get_diff_now(time_t start_time)
1174 {
1175         time_t curr_time;
1176         unsigned long call_duration_in_sec = 0;
1177         curr_time = time(&curr_time);
1178         call_duration_in_sec = curr_time - start_time;
1179         return call_duration_in_sec;
1180 }
1181
1182 gboolean _vcui_is_gcf_mode(void)
1183 {
1184         gboolean bgcf_status = EINA_FALSE;
1185         int ret = -1;
1186
1187         ret = vconf_get_int(VCONFKEY_ADMIN_GCF_TEST, &bgcf_status);
1188         if (0 == ret) {
1189                 CALL_UI_DEBUG("bgcf_status = [%d]\n", bgcf_status);
1190         } else {
1191                 CALL_UI_DEBUG("vconf_get_int failed..[%d]\n", ret);
1192         }
1193
1194         return bgcf_status;
1195 }
1196
1197 gboolean _vcui_is_headset_conected(void)
1198 {
1199         int bt_connected = VCONFKEY_BT_DEVICE_NONE;
1200         Eina_Bool ret = EINA_FALSE;
1201
1202         ret = vconf_get_int(VCONFKEY_BT_DEVICE, &bt_connected);
1203         if (0 == ret) {
1204                 CALL_UI_DEBUG("bt_connected = [0x%x] ", bt_connected);
1205         } else {
1206                 CALL_UI_DEBUG("vconf_get_int failed..[%d]", ret);
1207         }
1208
1209         return (VCONFKEY_BT_DEVICE_HEADSET_CONNECTED == (bt_connected & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED)) ? EINA_TRUE : EINA_FALSE;
1210 }
1211
1212 gboolean _vcui_is_headset_switch_on(void)
1213 {
1214         int bt_status = VCONFKEY_BT_STATUS_OFF;
1215         Eina_Bool ret = EINA_FALSE;
1216
1217         ret = vconf_get_int(VCONFKEY_BT_STATUS, &bt_status);
1218         if (0 == ret) {
1219                 CALL_UI_DEBUG("bt_status = [0x%x] ", bt_status);
1220         } else {
1221                 CALL_UI_DEBUG("vconf_get_int failed..[%d]", ret);
1222         }
1223
1224         return (VCONFKEY_BT_STATUS_ON == (bt_status & VCONFKEY_BT_STATUS_ON)) ? EINA_TRUE : EINA_FALSE;
1225 }
1226
1227 gboolean _vcui_is_answering_mode_on(void)
1228 {
1229         gboolean bAnswerMode = EINA_FALSE;
1230         Eina_Bool ret = EINA_FALSE;
1231
1232         ret = vconf_get_bool(VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, &bAnswerMode);
1233         if (0 == ret) {
1234                 CALL_UI_DEBUG("bAnswerMode = [%d] \n", bAnswerMode);
1235         } else {
1236                 CALL_UI_DEBUG("vconf_get_int failed..[%d]\n", ret);
1237         }
1238
1239         return bAnswerMode;
1240 }
1241
1242 gboolean _vcui_is_powerkey_mode_on(void)
1243 {
1244         gboolean bPowerkeyMode = EINA_FALSE;
1245         Eina_Bool ret = EINA_FALSE;
1246
1247         ret = vconf_get_bool(VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, &bPowerkeyMode);
1248         if (0 == ret) {
1249                 CALL_UI_DEBUG("bPowerkeyMode = [%d] \n", bPowerkeyMode);
1250         } else {
1251                 CALL_UI_DEBUG("vconf_get_int failed..[%d]\n", ret);
1252         }
1253
1254         return bPowerkeyMode;
1255 }
1256
1257 gboolean _vcui_is_phonelock_status()
1258 {
1259         gboolean b_phonelock = EINA_FALSE;
1260         if (!vconf_get_bool(VCONFKEY_SETAPPL_STATE_POWER_ON_LOCK_BOOL, &b_phonelock)) {
1261                 CALL_UI_DEBUG("b_phonelock:[%d]", b_phonelock);
1262                 return b_phonelock;
1263         } else {
1264                 CALL_UI_DEBUG("get VCONFKEY_SETAPPL_STATE_POWER_ON_LOCK_BOOL failed..");
1265                 return EINA_FALSE;
1266         }
1267 }
1268
1269 void _vcui_add_calllog(int type, call_data_t *data, int boutgoing_end)
1270 {
1271         CALL_UI_DEBUG("type = [0x%x] ", type);
1272         CTSvalue *plog;
1273         time_t current_time;
1274         int missed_cnt = 0;
1275
1276         if (data == NULL)
1277                 return;
1278         contacts_svc_connect();
1279
1280         current_time = time(NULL);
1281
1282         plog = contacts_svc_value_new(CTS_VALUE_PHONELOG);
1283         contacts_svc_value_set_str(plog, CTS_PLOG_VAL_NUMBER_STR, _vcui_doc_get_call_number(data));
1284         contacts_svc_value_set_int(plog, CTS_PLOG_VAL_LOG_TIME_INT, (int)current_time);
1285         contacts_svc_value_set_int(plog, CTS_PLOG_VAL_LOG_TYPE_INT, type);
1286         contacts_svc_value_set_int(plog, CTS_PLOG_VAL_RELATED_ID_INT, _vcui_doc_get_contact_index(data));
1287
1288         if ((type == CTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN) || (type == CTS_PLOG_TYPE_VOICE_REJECT) || (type == CTS_PLOG_TYPE_VOICE_BLOCKED) || (boutgoing_end == EINA_TRUE)) {
1289                 contacts_svc_value_set_int(plog, CTS_PLOG_VAL_DURATION_INT, 0);
1290         } else {
1291                 contacts_svc_value_set_int(plog, CTS_PLOG_VAL_DURATION_INT, _vcui_get_diff_now(_vcui_doc_get_call_start_time(data)));
1292         }
1293         contacts_svc_insert_phonelog(plog);
1294
1295         contacts_svc_value_free(plog);
1296         missed_cnt = contacts_svc_count(CTS_GET_UNSEEN_MISSED_CALL);
1297         contacts_svc_disconnect();
1298
1299         /* vconf set & quickpanel noti (for missed call) */
1300         if (type == CTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN) {
1301                 char szname[255] = { 0, };
1302                 char str_buf[1024] = { 0, };
1303                 int noti_flags = 0;
1304                 notification_h noti = NULL;
1305                 notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1306
1307                 if (strlen(_vcui_doc_get_call_display_name(data)) == 0) {
1308                         snprintf(szname, sizeof(szname), "%s", _vcui_doc_get_call_number(data));
1309                 } else {
1310                         snprintf(szname, sizeof(szname), "%s", _vcui_doc_get_call_display_name(data));
1311                 }
1312                 CALL_UI_DEBUG("szname:[%s]", szname);
1313
1314                 if (missed_cnt == 1) {
1315                         strncpy(str_buf, _("IDS_CALL_POP_CALLMISSED"), sizeof(str_buf) - 1);
1316                 } else {
1317                         char *temp = _("IDS_CALL_HEADER_PD_MISSED_CALLS");
1318                         snprintf(str_buf, sizeof(str_buf), temp, missed_cnt);
1319                 }
1320                 CALL_UI_DEBUG("Notification string :[%s]", str_buf);
1321
1322                 noti = notification_new(NOTIFICATION_TYPE_NOTI, __VCUI_NOTIFICATION_CALL_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
1323                 if (noti == NULL) {
1324                         CALL_UI_DEBUG("Fail to notification_new");
1325                         return;
1326                 }
1327
1328                 noti_err = notification_set_pkgname(noti, CALL_PKG_NAME);
1329                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1330                         CALL_UI_DEBUG("Fail to noification_set_pkgname %d", noti_err);
1331                 }
1332
1333                 noti_err = notification_set_application(noti, DIALER_PKG);
1334                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1335                         CALL_UI_DEBUG("Fail to notification_set_application : %d", noti_err);
1336                 }
1337
1338                 bundle *args = bundle_create();
1339
1340                 bundle_add(args, "logs", "missed_call");
1341                 noti_err = notification_set_args(noti, args, NULL);
1342                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1343                         CALL_UI_DEBUG("Fail to notification_set_args : %d", noti_err);
1344                 }
1345                 bundle_free(args);
1346
1347                 noti_err = notification_set_time(noti, current_time);
1348                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1349                         CALL_UI_DEBUG("Fail to notification_set_icon : %d", noti_err);
1350                 }
1351
1352                 /* Set notification single title*/
1353                 noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE, szname, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
1354                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1355                         CALL_UI_DEBUG("Fail to notification_set_text(single-title) : %d", noti_err);
1356                 }
1357
1358                 /* Set noitification single content*/
1359                 noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT, str_buf, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
1360                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1361                         CALL_UI_DEBUG("Fail to notification_set_text(single-content) : %d", noti_err);
1362                 }
1363
1364                 /* Set notification group title*/
1365                 noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_GROUP_TITLE, str_buf, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
1366                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1367                         CALL_UI_DEBUG("Fail to notification_set_text(group-title) : %d", noti_err);
1368                 }
1369
1370                 noti_flags = NOTIFICATION_PROP_DISABLE_TICKERNOTI | NOTIFICATION_PROP_DISPLAY_ONLY_SIMMODE;
1371                 noti_err = notification_set_property(noti, noti_flags);
1372                 if(noti_err != NOTIFICATION_ERROR_NONE) {
1373                         CALL_UI_DEBUG("Fail to notification_set_property : %d", noti_err);
1374                 }
1375
1376                 char *file_path = _vcui_doc_get_caller_id_file_path(data);
1377                 CALL_UI_DEBUG("data->call_file_path(%s)", file_path);
1378                 if ((strcmp(file_path, NOIMG_ICON) == 0)
1379                         || (missed_cnt > 1)) {
1380                         noti_err = notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_THUMBNAIL, NOTIFY_MISSED_CALL_ICON);
1381                 } else {
1382                         noti_err = notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_THUMBNAIL, file_path);
1383                 }
1384                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1385                         CALL_UI_DEBUG("Fail to notification_set_icon : %d", noti_err);
1386                 }
1387                 noti_err = notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_ICON, NOTIFY_SUB_MISSED_CALL_ICON);
1388                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1389                         CALL_UI_DEBUG("Fail to notification_set_icon : %d", noti_err);
1390                 }
1391
1392                 noti_err = notification_insert(noti, NULL);
1393                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1394                         CALL_UI_DEBUG("Fail to notification_set_text_domain");
1395                 }
1396
1397                 noti_err = notification_free(noti);
1398                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1399                         CALL_UI_DEBUG("Fail to notification_set_text_domain");
1400                 }
1401         }
1402 }
1403
1404 void _vcui_raise_main_win()
1405 {
1406         CALL_UI_DEBUG("..");
1407
1408         vcui_app_call_data_t *ad = _vcui_get_app_data();
1409         if (ad == NULL) {
1410                 CALL_UI_DEBUG("App data is NULL");
1411                 return;
1412         }
1413         if (ad->win_main == NULL) {
1414                 CALL_UI_DEBUG("Main Window is NULL");
1415                 return;
1416         }
1417
1418         elm_win_activate(ad->win_main);
1419         _vcui_show_main_ui_set_flag();
1420         /*view_refresh_now(); */
1421
1422 }
1423
1424 int _vcui_check_valid_eo(Evas_Object *eo, char *v_name)
1425 {
1426         /*CALL_UI_DEBUG("eo addr:[%p], v_name:[%s]", eo, v_name); */
1427         const char *obj_name = evas_object_name_get(eo);
1428         if (obj_name == NULL) {
1429                 CALL_UI_DEBUG("obj_name is NULL!!. eo addr:[%p], v_name:[%s]", eo, v_name);
1430                 return VC_ERROR;
1431         }
1432         if (strncmp(obj_name, v_name, strlen(obj_name)) == 0) {
1433                 return VC_NO_ERROR;
1434         } else {
1435                 CALL_UI_DEBUG("different name !! ");
1436                 return VC_ERROR;
1437         }
1438 }
1439
1440 vcui_app_call_data_t *_vcui_get_app_data()
1441 {
1442         return &global_ad;
1443 }
1444
1445 void _vcui_show_main_ui_set_flag()
1446 {
1447         vcui_app_call_data_t *ad = _vcui_get_app_data();
1448         if (ad->show_flag == WIN_HIDE) {
1449                 CALL_UI_DEBUG("show_flag : WIN_SHOW");
1450                 evas_object_show(ad->win_main);
1451                 ad->show_flag = WIN_SHOW;
1452         }
1453 }
1454
1455 void __vcui_hide_main_ui_set_flag()
1456 {
1457         vcui_app_call_data_t *ad = _vcui_get_app_data();
1458         CALL_UI_DEBUG("show_flag: WIN_HIDE");
1459         evas_object_hide(ad->win_main);
1460         ad->show_flag = WIN_HIDE;
1461 }
1462
1463 Evas_Object *_vcui_load_edj(Evas_Object *parent, const char *file, const char *group)
1464 {
1465         Evas_Object *eo;
1466         int r;
1467
1468         eo = elm_layout_add(parent);
1469         if (eo) {
1470                 r = elm_layout_file_set(eo, file, group);
1471                 if (!r) {
1472                         evas_object_del(eo);
1473                         CALL_UI_DEBUG("ERROR!!");
1474                         return NULL;
1475                 }
1476
1477                 evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1478                 elm_win_resize_object_add(parent, eo);
1479         }
1480
1481         return eo;
1482 }
1483
1484 int main(int argc, char *argv[])
1485 {
1486         CALL_UI_DEBUG("voice call ui main()..");
1487
1488         struct appcore_ops ops = {
1489                 .create = __vcui_app_create,
1490                 .terminate = __vcui_app_terminate,
1491                 .pause = __vcui_app_pause,
1492                 .resume = __vcui_app_resume,
1493                 .reset = __vcui_app_reset,
1494         };
1495
1496         memset(&global_ad, 0, sizeof(vcui_app_call_data_t));
1497
1498         ops.data = &global_ad;
1499
1500         CALL_UI_KPI("__vcui_init start");
1501         __vcui_init(&global_ad);
1502         CALL_UI_KPI("__vcui_init done");
1503
1504         appcore_set_i18n(PACKAGE, LOCALEDIR);
1505
1506         return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
1507 }
1508
1509 static Eina_Bool __vcui_avoid_multi_setup_timer_cb(void *data)
1510 {
1511         CALL_UI_DEBUG("..");
1512
1513         g_avoid_multi_setup = EINA_FALSE;
1514
1515         return ECORE_CALLBACK_CANCEL;
1516 }
1517
1518 static void __vcui_app_callback(int event, void *pdata, void *puser_data)
1519 {
1520         vcui_app_call_data_t *ad = (vcui_app_call_data_t *)puser_data;
1521         vc_engine_msg_type *msg = (vc_engine_msg_type *)pdata;
1522
1523         if ((ad == NULL) || (msg == NULL)) {
1524                 CALL_UI_DEBUG("ERROR.NULL pointer");
1525                 return;
1526         }
1527         CALL_UI_DEBUG("@@@ event:[%s], view_top:[%d], count:[%d]  @@@ \n", gszcall_callback_msg[event], ad->view_top, _vcui_doc_get_all_call_data_count());
1528
1529         switch (event) {
1530         case VC_ENGINE_MSG_INCOM_TO_UI:
1531                 {
1532                         vcall_engine_device_control_lcd_state(VC_LCD_ON_LOCK);
1533
1534                         CALL_UI_DEBUG("num:[%s], name:[%s]", msg->incoming.call_num, msg->incoming.call_name);
1535
1536                         call_data_t *call_data = NULL;
1537                         call_data = _vcui_doc_allocate_call_data_memory();
1538                         if (call_data == NULL) {
1539                                 CALL_UI_DEBUG("Error");
1540                                 elm_exit();
1541                                 return;
1542                         }
1543                         _vcui_doc_set_call_handle(call_data, msg->incoming.call_handle);
1544                         _vcui_doc_set_contact_index(call_data, msg->incoming.contact_index);
1545                         _vcui_doc_set_contact_phone_type(call_data, msg->incoming.phone_type);
1546                         _vcui_doc_set_birthday_remaining_days(call_data, msg->incoming.bday_remaining_days);
1547                         _vcui_doc_set_call_number(call_data, msg->incoming.call_num);
1548
1549                         if (msg->incoming.brestricted == EINA_TRUE) {
1550                                 if (msg->incoming.bpayphone == EINA_TRUE) {
1551                                         _vcui_doc_set_call_display_name(call_data, _("Payphone"));
1552                                 } else {
1553                                         _vcui_doc_set_call_display_name(call_data, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1554                                 }
1555                         } else {
1556                                 _vcui_doc_set_call_display_name(call_data, msg->incoming.call_name);
1557                         }
1558
1559                         if ((strcmp((char *)msg->incoming.call_file_path, "default") == 0) || (strlen((char *)msg->incoming.call_file_path) == 0)) {
1560                                 _vcui_doc_set_caller_id_file_path(call_data, NOIMG_ICON);
1561                         } else {
1562                                 _vcui_doc_set_caller_id_file_path(call_data, msg->incoming.call_file_path);
1563                         }
1564
1565                         if ((strcmp((char *)msg->incoming.call_full_file_path, "default") == 0) || (strlen((char *)msg->incoming.call_full_file_path) == 0)) {
1566                                 _vcui_doc_set_caller_id_full_file_path(call_data, NOIMG_ICON);
1567                         } else {
1568                                 _vcui_doc_set_caller_id_full_file_path(call_data, msg->incoming.call_full_file_path);
1569                         }
1570                         _vcui_doc_set_call_status(call_data, NO_STATUS);
1571                         _vcui_doc_set_call_type(call_data, CALL_INCOMING);
1572                         _vcui_doc_set_auto_reject_status(call_data, msg->incoming.brejected);
1573
1574                         _vcui_doc_set_recent_mt_call_data(call_data);
1575                         _vcui_doc_add_call_data(call_data);
1576
1577                         {
1578                                 /*Auto Reject Check */
1579                                 if (EINA_TRUE == msg->incoming.brejected) {
1580                                         CALL_UI_DEBUG("the call rejected and show reject popup");
1581                                         vcall_engine_reject_call();
1582                                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_BLOCKED, call_data, EINA_FALSE);
1583
1584                                         if (_vcui_doc_get_all_call_data_count() > 1) {
1585                                                 _vcui_view_popup_load_reject_call(_vcui_doc_get_call_display_name(call_data), _vcui_doc_get_call_number(call_data), EINA_FALSE);
1586                                         } else {
1587                                                 _vcui_view_popup_load_reject_call(_vcui_doc_get_call_display_name(call_data), _vcui_doc_get_call_number(call_data), EINA_TRUE);
1588                                         }
1589                                 } else {
1590                                         _vcui_view_change(VIEW_INCOMING_LOCK_VIEW, 0, NULL, NULL);
1591                                 }
1592                         }
1593                 }
1594                 break;
1595
1596         case VC_ENGINE_MSG_OUTGOING_TO_UI:
1597                 {
1598                         call_data_t *call_data = NULL;
1599                         call_data = _vcui_doc_allocate_call_data_memory();
1600                         if (call_data == NULL) {
1601                                 CALL_UI_DEBUG("Error");
1602                                 elm_exit();
1603                                 return;
1604                         }
1605
1606                         _vcui_doc_set_call_handle(call_data, NO_HANDLE);
1607                         _vcui_doc_set_contact_index(call_data, msg->outgoing.contact_index);
1608                         _vcui_doc_set_contact_phone_type(call_data, msg->outgoing.phone_type);
1609                         _vcui_doc_set_birthday_remaining_days(call_data, msg->outgoing.bday_remaining_days);
1610                         _vcui_doc_set_call_number(call_data, msg->outgoing.call_num);
1611                         _vcui_doc_set_call_display_name(call_data, msg->outgoing.call_name);
1612
1613                         if ((strcmp((char *)msg->outgoing.call_file_path, "default") == 0) || (strlen((char *)msg->outgoing.call_file_path) == 0)) {
1614                                 _vcui_doc_set_caller_id_file_path(call_data, NOIMG_ICON);
1615                         } else {
1616                                 _vcui_doc_set_caller_id_file_path(call_data, msg->outgoing.call_file_path);
1617                         }
1618
1619                         if ((strcmp((char *)msg->outgoing.call_full_file_path, "default") == 0) || (strlen((char *)msg->outgoing.call_full_file_path) == 0)) {
1620                                 _vcui_doc_set_caller_id_full_file_path(call_data, NOIMG_ICON);
1621                         } else {
1622                                 _vcui_doc_set_caller_id_full_file_path(call_data, msg->outgoing.call_full_file_path);
1623                         }
1624                         _vcui_doc_set_call_status(call_data, NO_STATUS);
1625                         _vcui_doc_set_call_type(call_data, CALL_OUTGOING);
1626                         _vcui_doc_set_call_start_time(call_data);
1627
1628                         _vcui_doc_set_recent_mo_call_data(call_data);
1629                 }
1630                 break;
1631
1632         case VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI:
1633                 {
1634                         vcall_engine_device_control_lcd_state(VC_LCD_ON_LOCK);
1635
1636                         vc_engine_outgoing_orig_type outgoing_orig = msg->outgoing_orig;
1637
1638                         call_data_t *call_data = _vcui_doc_get_recent_mo_call_data();
1639                         _vcui_doc_set_call_handle(call_data, outgoing_orig.call_handle);
1640
1641                         if (outgoing_orig.bemergency == EINA_TRUE) {
1642                                 CALL_UI_DEBUG("it is emergency call");
1643                                 char *em_name = _("IDS_CALL_POP_EMERGENCY_CALL");
1644                                 _vcui_doc_set_call_display_name(call_data, em_name);
1645                                 _vcui_doc_set_caller_id_file_path(call_data, NOIMG_ICON);
1646                                 _vcui_doc_set_caller_id_full_file_path(call_data, NOIMG_ICON);
1647                                 _vcui_doc_set_contact_phone_type(call_data, -1);
1648                                 _vcui_doc_set_birthday_remaining_days(call_data, -1);
1649                         }
1650
1651                         _vcui_doc_add_call_data(call_data);
1652                         _vcui_view_change(VIEW_DIALLING_VIEW, 0, NULL, NULL);
1653
1654                         /*Update the quick-panel window */
1655                         _vcui_view_quickpanel_change();
1656                         _vcui_view_qp_update_text_status(ad->view_st[VIEW_QUICKPANEL_VIEW], _("IDS_CALL_POP_CALLING"));
1657                 }
1658                 break;
1659
1660         case VC_ENGINE_MSG_OUTGOING_ORIG_TO_UI_TEST:
1661                 {
1662                         vcall_engine_device_control_lcd_state(VC_LCD_ON_LOCK);
1663
1664                         vc_engine_outgoing_orig_type outgoing_orig = msg->outgoing_orig;
1665
1666                         call_data_t *call_data = _vcui_doc_get_recent_mo_call_data();
1667                         _vcui_doc_set_call_handle(call_data, 1);
1668
1669                         if (outgoing_orig.bemergency == EINA_TRUE) {
1670                                 CALL_UI_DEBUG("it is emergency call");
1671                                 char *em_name = _("IDS_CALL_POP_EMERGENCY_CALL");
1672                                 _vcui_doc_set_call_display_name(call_data, em_name);
1673                                 _vcui_doc_set_caller_id_file_path(call_data, NOIMG_ICON);
1674                                 _vcui_doc_set_caller_id_full_file_path(call_data, NOIMG_ICON);
1675                                 _vcui_doc_set_contact_phone_type(call_data, -1);
1676                                 _vcui_doc_set_birthday_remaining_days(call_data, -1);
1677                         }
1678
1679                         _vcui_doc_add_call_data(call_data);
1680                         _vcui_view_change(VIEW_DIALLING_VIEW, 0, NULL, NULL);
1681
1682                         /*Update the quick-panel window */
1683                         _vcui_view_quickpanel_change();
1684                         _vcui_view_qp_update_text_status(ad->view_st[VIEW_QUICKPANEL_VIEW], _("IDS_CALL_POP_CALLING"));
1685                 }
1686                 break;
1687
1688         case VC_ENGINE_MSG_OUTGOING_ALERT_TO_UI:
1689                 {
1690                         call_data_t *call_data = _vcui_doc_get_recent_mo_call_data();
1691                         if (_vcui_doc_is_valid_call_data(call_data) == EINA_FALSE) {
1692                                 CALL_UI_DEBUG("Error. check outgoing_orig msg.");
1693                                 elm_exit();
1694                                 return;
1695                         }
1696
1697                         _vcui_view_qp_update_text_status(ad->view_st[VIEW_QUICKPANEL_VIEW], _("IDS_CALL_POP_CALLING"));
1698                 }
1699                 break;
1700
1701         case VC_ENGINE_MSG_CONNECTED_TO_UI:
1702                 {
1703                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
1704
1705                         vc_engine_connected_type connected = msg->connected;
1706                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(connected.call_handle);
1707                         if (_vcui_doc_is_valid_call_data(call_data) == EINA_FALSE) {
1708                                 CALL_UI_DEBUG("Error");
1709                                 elm_exit();
1710                                 return;
1711                         }
1712                         _vcui_doc_set_call_status(call_data, CALL_UNHOLD);
1713                         _vcui_doc_set_call_handle(call_data, connected.call_handle);
1714                         _vcui_doc_set_call_start_time(call_data);
1715                         /* When new call connected, if it's multiparty call, always show split1 first. */
1716                         ad->bswapped = EINA_FALSE;
1717
1718                         _vcui_view_auto_change();
1719
1720                         /*Update the quick-panel window */
1721                         _vcui_view_quickpanel_change();
1722                 }
1723                 break;
1724
1725         case VC_ENGINE_MSG_NORMAL_END_TO_UI:
1726                 {
1727                         vcall_engine_device_control_lcd_state(VC_LCD_ON_LOCK);
1728
1729                         vc_engine_normal_end_type normal_end = msg->normal_end;
1730
1731                         CALL_UI_DEBUG("end_cause_type:[%d]", normal_end.end_cause_type);
1732
1733                         vcui_app_call_data_t *ad = _vcui_get_app_data();
1734                         time_t start_time;
1735                         int     call_type = -1;
1736
1737                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(normal_end.call_handle);
1738                         if (_vcui_doc_is_valid_call_data(call_data) == EINA_FALSE) {
1739                                 CALL_UI_DEBUG("Error");
1740                                 elm_exit();
1741                                 return;
1742                         }
1743                         call_type = _vcui_doc_get_call_type(call_data);
1744                         CALL_UI_DEBUG("call_type: %d", call_type);
1745                         if (call_type == CALL_OUTGOING) {
1746                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_FALSE);
1747                         } else if (call_type == CALL_INCOMING) {
1748                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_INCOMMING, call_data, EINA_FALSE);
1749                         }
1750                         start_time = _vcui_doc_get_call_start_time(call_data);
1751
1752
1753                         if (_vcui_doc_get_all_call_data_count() == 1 && ad->view_top == VIEW_INCALL_ONECALL_VIEW) {
1754                                 ad->call_end_type = CALL_END_TYPE_SINGLE_CALL;
1755                         }
1756                         CALL_UI_DEBUG("ad->call_end_type[%d]", ad->call_end_type);
1757
1758                         if (ad->call_end_type == CALL_END_TYPE_SINGLE_CALL) {
1759                                 CALL_UI_DEBUG("Show end screen - %d", ad->call_end_type);
1760                                 _vcui_view_change(VIEW_ENDCALL_VIEW, -1, call_data, NULL);
1761                                 ad->call_end_type = CALL_END_TYPE_NONE;
1762                                 CALL_UI_DEBUG("Blink show: end call time");
1763                                 _vcui_view_common_call_end_show(start_time, normal_end.end_cause_type);
1764                                 _vcui_doc_remove_call_data(call_data);
1765                         } else if (ad->call_end_type == CALL_END_TYPE_CONF_CALL) {
1766                                 if (_vcui_doc_get_all_call_data_count() == 1) {
1767                                         ad->call_end_type = CALL_END_TYPE_NONE;
1768                                 } else if (ad->view_top != VIEW_ENDCALL_VIEW) {
1769                                         _vcui_view_change(VIEW_ENDCALL_VIEW, -1, call_data, NULL);
1770                                         _vcui_view_common_call_end_show(start_time, normal_end.end_cause_type);
1771                                 }
1772                                 _vcui_doc_remove_call_data(call_data);
1773                         } else {
1774                                 _vcui_doc_remove_call_data(call_data);
1775                                 _vcui_view_common_call_terminate_or_view_change();
1776                         }
1777                         /*Update the quick-panel window */
1778                         _vcui_view_quickpanel_change();
1779                 }
1780                 break;
1781
1782         case VC_ENGINE_MSG_INCOM_END_TO_UI:
1783                 {
1784                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
1785
1786                         vc_engine_common_with_handle_type incom_end = msg->incom_end;
1787
1788                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(incom_end.call_handle);
1789                         if (_vcui_doc_is_valid_call_data(call_data) == EINA_FALSE) {
1790                                 CALL_UI_DEBUG("Error");
1791                                 elm_exit();
1792                                 return;
1793                         }
1794                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN, call_data, EINA_FALSE);
1795                         _vcui_doc_remove_call_data(call_data);
1796                         _vcui_view_common_call_terminate_or_view_change();
1797                 }
1798                 break;
1799
1800         case VC_ENGINE_MSG_REJECTED_END_TO_UI:
1801                 {
1802                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
1803
1804                         vc_engine_common_with_handle_type rejected_end = msg->rejected_end;
1805
1806                         call_data_t *pcall_data = _vcui_doc_get_call_data_by_handle(rejected_end.call_handle);
1807                         if (_vcui_doc_is_valid_call_data(pcall_data) == EINA_FALSE) {
1808                                 CALL_UI_DEBUG("Error");
1809                                 elm_exit();
1810                                 return;
1811                         }
1812
1813                         if (_vcui_doc_get_auto_reject_status(pcall_data) == EINA_TRUE) {
1814                                 CALL_UI_DEBUG("auto rejected.");
1815                                 _vcui_doc_remove_call_data(pcall_data);
1816                         } else {
1817                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_REJECT, pcall_data, EINA_FALSE);
1818                                 _vcui_doc_remove_call_data(pcall_data);
1819                                 _vcui_view_common_call_terminate_or_view_change();
1820                         }
1821                 }
1822                 break;
1823
1824         case VC_ENGINE_MSG_OUTGOING_END_TO_UI:
1825                 {
1826                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
1827
1828                         vc_engine_outgoing_end_type outgoing_end = msg->outgoing_end;
1829                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(outgoing_end.call_handle);
1830                         if (_vcui_doc_is_valid_call_data(call_data) == EINA_FALSE) {
1831                                 CALL_UI_DEBUG("It is the case which call orig is not received.");
1832                                 char data[VC_DATA_LENGTH_MAX] = { 0, };
1833                                 _vcui_view_popup_load(_vcui_get_endcause_string(outgoing_end.end_cause_type, data), POPUP_TIMEOUT_LONG, EINA_TRUE);
1834                         } else {
1835                                 _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_TRUE);
1836                                 if (outgoing_end.bauto_redial == EINA_TRUE) {
1837                                         CALL_UI_DEBUG("bauto_redial is EINA_TRUE");
1838                                         _vcui_doc_remove_call_data_from_list(call_data);
1839                                 } else {
1840                                         CALL_UI_DEBUG("show the call end screen");
1841                                         vcui_app_call_data_t *ad = _vcui_get_app_data();
1842                                         if (_vcui_doc_get_all_call_data_count() == 1 && ad->view_top == VIEW_DIALLING_VIEW) {
1843                                                 ad->call_end_type = CALL_END_TYPE_SINGLE_CALL;
1844                                                 _vcui_view_change(VIEW_ENDCALL_VIEW, -1, call_data, NULL);
1845                                         }
1846                                         _vcui_doc_remove_call_data(call_data);
1847                                 }
1848                                 _vcui_view_common_call_end_show_dialing(outgoing_end.end_cause_type, outgoing_end.bauto_redial);
1849                         }
1850
1851                 }
1852                 break;
1853
1854         case VC_ENGINE_MSG_OUTGOING_END_SIGNAL_PLAY_TO_UI:
1855                 {
1856                         vc_engine_outgoing_end_signal_play_type outgoing_end_signal_play = msg->outgoing_end_signal_play;
1857                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(outgoing_end_signal_play.call_handle);
1858                         if (call_data != NULL) {
1859                                 _vcui_view_dialing_draw_txt_ended(ad->view_st[ad->view_top], outgoing_end_signal_play.end_cause_type);
1860                         } else {
1861                                 CALL_UI_DEBUG("Check it whether call data exists. handle:[%d]", outgoing_end_signal_play.call_handle);
1862                         }
1863                 }
1864                 break;
1865
1866         case VC_ENGINE_MSG_OUTGOING_ABORTED_TO_UI:
1867                 {
1868                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
1869
1870                         vc_engine_common_with_handle_type outgoing_aborted = msg->outgoing_aborted;
1871                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(outgoing_aborted.call_handle);
1872                         if (call_data == NULL)
1873                                 call_data = _vcui_doc_get_recent_mo_call_data();
1874
1875                         if (call_data == NULL) {
1876                                 CALL_UI_DEBUG("Error");
1877                                 elm_exit();
1878                                 return;
1879                         }
1880
1881                         _vcui_add_calllog(CTS_PLOG_TYPE_VOICE_OUTGOING, call_data, EINA_TRUE);
1882
1883                         _vcui_doc_remove_call_data(call_data);
1884
1885                         _vcui_view_common_call_terminate_or_view_change();
1886
1887                 }
1888                 break;
1889
1890         case VC_ENGINE_MSG_DTMF_ACK_TO_UI:
1891                 {
1892
1893                         vc_engine_dtmf_ack_type dtmf_ack = msg->dtmf_progress;
1894
1895                         if (EINA_FALSE == dtmf_ack.bstatus) {
1896                                 _vcui_view_popup_unload_progress(ad);
1897                                 if ((dtmf_ack.string_id != -1) && (dtmf_ack.string_id != IDS_CALL_POP_DTMF_SENT)) {
1898                                         CALL_UI_DEBUG("load popup window... Start");
1899                                         _vcui_view_popup_load(_(gszcall_error_msg[dtmf_ack.string_id]), POPUP_TIMEOUT_LONG, EINA_FALSE);
1900                                 }
1901                         } else {
1902                                 CALL_UI_DEBUG("display_string:[%s], string_id:[%d]", dtmf_ack.display_string, dtmf_ack.string_id);
1903                                 if (dtmf_ack.string_id == IDS_CALL_POP_UNAVAILABLE) {   /*check for the ID when string is added */
1904                                         _vcui_view_load_send_dtmf_popup_with_buttons(_("Send DTMF tones?"), dtmf_ack.display_string);   /*add the string */
1905                                 } else if (dtmf_ack.string_id == IDS_CALL_POP_SENDING) {
1906                                         _vcui_view_popup_load_sending_dtmf(_(gszcall_error_msg[dtmf_ack.string_id]), dtmf_ack.display_string);
1907                                 }
1908                         }
1909                 }
1910                 break;
1911
1912         case VC_ENGINE_MSG_SS_HELD_TO_UI:
1913                 {
1914                         _vcui_doc_set_all_call_data_to_hold_status();
1915                         _vcui_view_update();
1916                         /*Update the quick-panel window */
1917                         _vcui_view_quickpanel_change();
1918
1919                 }
1920                 break;
1921
1922         case VC_ENGINE_MSG_SS_RETREIVED_TO_UI:
1923                 {
1924                         _vcui_doc_set_all_call_data_to_unhold_status();
1925                         _vcui_view_update();
1926                         /*Update the quick-panel window */
1927                         _vcui_view_quickpanel_change();
1928
1929                 }
1930                 break;
1931
1932         case VC_ENGINE_MSG_SS_SWAP_TO_UI:
1933                 {
1934                         _vcui_view_popup_unload(ad->popup_eo);
1935
1936                         if (ad->bholdisleft == EINA_TRUE) {
1937                                 ad->bswapped = EINA_FALSE;
1938                         } else {
1939                                 ad->bswapped = EINA_TRUE;
1940                         }
1941
1942                         _vcui_doc_swap_all_call_data_status();
1943                         _vcui_view_auto_change();
1944                         /*Update the quick-panel window */
1945                         _vcui_view_quickpanel_change();
1946                 }
1947                 break;
1948
1949         case VC_ENGINE_MSG_SS_SETUP_CONF_TO_UI:
1950                 {
1951                         _vcui_view_popup_unload(ad->popup_eo);
1952
1953                         _vcui_doc_set_all_call_data_to_unhold_status();
1954                         _vcui_view_auto_change();
1955                         /*Update the quick-panel window */
1956                         _vcui_view_quickpanel_change();
1957                 }
1958                 break;
1959
1960         case VC_ENGINE_MSG_SS_SPLIT_CONF_TO_UI:
1961                 {
1962                         vc_engine_common_with_handle_type ss_split_conf = msg->ss_split_conf;
1963
1964                         CALL_UI_DEBUG("[UI]The handle is %d ", ss_split_conf.call_handle);
1965
1966                         call_data_t *call_data = _vcui_doc_get_call_data_by_handle(ss_split_conf.call_handle);
1967                         if (call_data == NULL) {
1968                                 CALL_UI_DEBUG("Error");
1969                                 elm_exit();
1970                                 return;
1971                         } else {
1972                                 _vcui_doc_set_all_call_data_to_hold_status();
1973                                 _vcui_doc_set_call_status(call_data, CALL_UNHOLD);
1974
1975                                 _vcui_view_auto_change();
1976                                 /*Update the quick-panel window */
1977                                 _vcui_view_quickpanel_change();
1978                         }
1979                 }
1980                 break;
1981
1982         case VC_ENGINE_MSG_SS_TRANSFERRED_TO_UI:
1983                 break;
1984
1985         case VC_ENGINE_MSG_SS_CONNECT_LINE_IND_TO_UI:
1986                 break;
1987
1988         case VC_ENGINE_MSG_IND_FORWARD_TO_UI:
1989                 break;
1990
1991         case VC_ENGINE_MSG_IND_ACTIVATE_TO_UI:
1992                 {
1993                         _vcui_view_popup_load(_("IDS_CALL_POP_UNHELD"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
1994                 }
1995                 break;
1996
1997         case VC_ENGINE_MSG_IND_HOLD_TO_UI:
1998                 {
1999                         _vcui_view_popup_load(_("IDS_CALL_POP_HELD"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
2000                 }
2001                 break;
2002
2003         case VC_ENGINE_MSG_IND_TRANSFER_TO_UI:
2004                 break;
2005
2006         case VC_ENGINE_MSG_IND_SETUPCONFERENCE_TO_UI:
2007                 break;
2008
2009         case VC_ENGINE_MSG_IND_BARRING_TO_UI:
2010                 break;
2011
2012         case VC_ENGINE_MSG_IND_WAITING_TO_UI:
2013                 {
2014                         _vcui_view_popup_load(_("IDS_CALL_POP_WAITING_ACTIVE"), POPUP_TIMEOUT_SHORT, EINA_FALSE);
2015                 }
2016                 break;
2017
2018         case VC_ENGINE_MSG_IND_CUGINFO_TO_UI:
2019                 break;
2020
2021         case VC_ENGINE_MSG_IND_SSNOTIFY_TO_UI:
2022                 break;
2023
2024         case VC_ENGINE_MSG_IND_CALLINGNAMEINFO_TO_UI:
2025                 break;
2026
2027         case VC_ENGINE_MSG_IND_REDIRECT_CNF_TO_UI:
2028                 break;
2029
2030         case VC_ENGINE_MSG_IND_ACTIVATECCBS_CNF_TO_UI:
2031                 break;
2032
2033         case VC_ENGINE_MSG_IND_ACTIVATECCBS_USERINFO_TO_UI:
2034                 break;
2035
2036         case VC_ENGINE_MSG_GET_VOLUME_RESP_TO_UI:
2037                 {
2038                         vc_engine_vol_resp_type vol_resp = msg->vol_resp;
2039                         _vcui_response_volume(vol_resp.vol_alert_type, vol_resp.vol_level);
2040                 }
2041                 break;
2042
2043         case VC_ENGINE_MSG_SET_VOLUME_FROM_BT_TO_UI:
2044                 {
2045                         vc_engine_vol_set_from_bt_type vol_set_from_bt = msg->vol_set_from_bt;
2046                         ad->bt_vol_val = vol_set_from_bt.vol_level;
2047                         _vcui_view_popup_vol_bt(ad->bt_vol_val);
2048                 }
2049                 break;
2050
2051         case VC_ENGINE_MSG_ACTION_NO_ACTIVE_TASK_TO_UI:
2052                 {
2053
2054                 }
2055                 break;
2056
2057         case VC_ENGINE_MSG_ACTION_CALL_END_HELD_RETREIVED_TO_UI:
2058                 {
2059
2060                 }
2061                 break;
2062
2063         case VC_ENGINE_MSG_ACTION_SAT_RESPONSE_TO_UI:
2064                 {
2065
2066                 }
2067                 break;
2068
2069         case VC_ENGINE_MSG_ACTION_SAT_REQUEST_TO_UI:
2070                 {
2071
2072                 }
2073                 break;
2074
2075         case VC_ENGINE_MSG_ERROR_OCCURED_TO_UI:
2076                 break;
2077
2078         case VC_ENGINE_MSG_IND_AOC_TO_UI:
2079                 break;
2080
2081         case VC_ENGINE_MSG_ACCEPT_CHOICE_BOX_TO_UI:
2082                 {
2083                         CALL_UI_DEBUG("not supported");
2084                 }
2085                 break;
2086
2087         case VC_ENGINE_MSG_HEADSET_STATUS_TO_UI:
2088                 {
2089                         vc_engine_headset_status_type headset_status = msg->headset_status;
2090                         ad->headset_status = headset_status.bstatus;
2091                         if (ad->headset_status == EINA_TRUE) {
2092                                 ad->speaker_status = EINA_FALSE;
2093                         }
2094                         CALL_UI_DEBUG("Headset Status = %d", ad->headset_status);
2095                         CALL_UI_DEBUG("ad->view_top:[%d]", ad->view_top);
2096
2097                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
2098                             || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
2099                                 if (ad->view_st[ad->view_top] != NULL) {
2100                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
2101                                 }
2102                         }
2103
2104                 }
2105                 break;
2106
2107         case VC_ENGINE_MSG_EARJACK_STATUS_TO_UI:
2108                 {
2109                         vc_engine_earjack_status_type earjack_status = msg->earjack_status;
2110
2111                         CALL_UI_DEBUG("earjack Status = %d", earjack_status.bstatus);
2112                         CALL_UI_DEBUG("ad->view_top:[%d]", ad->view_top);
2113
2114                         if (earjack_status.bstatus == EINA_TRUE) {
2115                                 if (ad->ctxpopup_radio_group_eo != NULL)
2116                                         elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_RECEIVER_EARJACK);
2117
2118                                 ad->speaker_status = EINA_FALSE;
2119                                 ad->headset_status = EINA_FALSE;
2120
2121                                 if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
2122                                     || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
2123                                         if (ad->view_st[ad->view_top] != NULL) {
2124                                                 ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
2125                                         }
2126                                 }
2127                         } else {
2128                                 if (_vcui_is_headset_conected() == EINA_TRUE) {
2129                                         if (ad->ctxpopup_radio_group_eo != NULL)
2130                                                 elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_HEADSET);
2131
2132                                         ad->speaker_status = EINA_FALSE;
2133                                         ad->headset_status = EINA_TRUE;
2134
2135                                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
2136                                             || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
2137                                                 if (ad->view_st[ad->view_top] != NULL) {
2138                                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
2139                                                 }
2140                                         }
2141                                 } else {
2142                                         if (ad->ctxpopup_radio_group_eo != NULL)
2143                                                 elm_radio_value_set(ad->ctxpopup_radio_group_eo, VCUI_SND_PATH_RECEIVER_EARJACK);
2144
2145                                         ad->speaker_status = EINA_FALSE;
2146                                         ad->headset_status = EINA_FALSE;
2147
2148                                         if ((ad->view_top == VIEW_INCALL_ONECALL_VIEW) || (ad->view_top == VIEW_INCALL_MULTICALL_SPLIT_VIEW)
2149                                             || (ad->view_top == VIEW_INCALL_MULTICALL_CONF_VIEW) || (ad->view_top == VIEW_DIALLING_VIEW)) {
2150                                                 if (ad->view_st[ad->view_top] != NULL) {
2151                                                         ad->view_st[ad->view_top]->onUpdate(ad->view_st[ad->view_top], NULL, NULL);
2152                                                 }
2153                                         }
2154                                 }
2155                         }
2156                 }
2157                 break;
2158
2159         case VC_ENGINE_MSG_ACTION_INCOM_FORCE_TO_UI:
2160                 {
2161                         call_data_t *call_data = _vcui_doc_get_recent_mo_call_data();
2162                         if (call_data != NULL && _vcui_doc_get_call_handle(call_data) == NO_HANDLE) {
2163                                 _vcui_doc_remove_call_data_from_list(call_data);
2164                                 _vcui_doc_set_recent_mo_call_data(NULL);
2165                         }
2166                 }
2167                 break;
2168
2169         case VC_ENGINE_MSG_MESSAGE_BOX_TO_UI:
2170                 {
2171                         vcall_engine_device_control_lcd_state(VC_LCD_ON_UNLOCK);
2172
2173                         vc_engine_msg_box_type msg_box = msg->msg_box;
2174                         _vcui_view_popup_load(_(gszcall_error_msg[msg_box.string_id]), POPUP_TIMEOUT_LONG, EINA_TRUE);
2175                 }
2176                 break;
2177
2178         case VC_ENGINE_MSG_REDIAL_TO_UI:
2179                 {
2180                         CALL_UI_DEBUG("not used");
2181                 }
2182                 break;
2183
2184         case VC_ENGINE_MSG_NOTI_WBAMR_TO_UI:
2185                 {
2186                         vc_engine_wbamr_status_type wbamr_status = msg->wbamr_status;
2187                         ad->wbamr_status = wbamr_status.bstatus;
2188                 }
2189                 break;
2190         default:
2191                 break;
2192         }
2193
2194         _vcui_doc_print_all_call_data(gszcall_callback_msg[event]);
2195
2196         CALL_UI_DEBUG("End..");
2197 }