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