ui/src/vcui-view-incoming-lock.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 #include <msg.h>
  18 #include <msg_transport.h>
  19 #include <dlfcn.h>
  20
  21 #include "vcui-application.h"
  22 #include "vcui-app-window.h"
  23 #include "vcui-view-incoming-lock.h"
  24 #include "vcui-view-layout-hd.h"
  25
  26 #define VCUI_REJECT_MSG_LENGTH_MAX (140+1)
  27 #define REJ_MSG_GENLIST_DATA "reject_msg_genlist_data"
  28 #define REJ_MSG_LIST_OPEN_STATUS_KEY "list_open_status_key"
  29 #define REJ_MSG_GENLIST_INDEX "reject_msg_genlist_index"
  30 #define VCUI_CST_REJECT_MSG_GET "cst_reject_msg_get"
  31 #define VCUI_CST_SO_PATH        "/opt/ug/lib/libug-setting-call-efl.so"
  32 #define VIEW_INCOMING_LOCK_LAYOUT_ID "INCOMINGLOCKVIEW"
  33
  34 typedef struct {
  35         Evas_Object *contents;
  36         Evas_Object *caller_info;
  37         Evas_Object *ic;
  38         Evas_Object *lock_reject_with_msg;
  39         Evas_Object *msg_glist;
  40
  41         double y_scale_factor;
  42
  43         int reject_with_msg_start_y;
  44         int reject_with_msg_cur_y;
  45
  46         int msg_list_height;
  47
  48         gboolean bmouse_down_pressed;   /*Tracks the mouse-down, mouse-move and mouse-up events are executed in sequence*/
  49
  50         void *dl_handle;
  51         Elm_Genlist_Item_Class *itc_reject_msg;
  52         Evas_Coord y_momentum;
  53         char *(*msg_func_ptr) (int);
  54         char reject_msg[VCUI_REJECT_MSG_LENGTH_MAX];
  55 } incoming_lock_view_priv_t;
  56
  57 static int __vcui_view_incoming_lock_oncreate(voice_call_view_data_t *view_data, int param1, void *param2, void *param3);
  58 static int __vcui_view_incoming_lock_onupdate(voice_call_view_data_t *view_data, void *update_data1, void *update_data2);
  59 static int __vcui_view_incoming_lock_onhide(voice_call_view_data_t *view_data);
  60 static int __vcui_view_incoming_lock_onshow(voice_call_view_data_t *view_data);
  61 static int __vcui_view_incoming_lock_ondestroy(voice_call_view_data_t *view_data);
  62
  63 static voice_call_view_data_t s_view = {
  64         .type = VIEW_INCOMING_LOCK_VIEW,
  65         .app_data = NULL,
  66         .layout = NULL,
  67         .onCreate = __vcui_view_incoming_lock_oncreate,
  68         .onUpdate = __vcui_view_incoming_lock_onupdate,
  69         .onHide = __vcui_view_incoming_lock_onhide,
  70         .onShow = __vcui_view_incoming_lock_onshow,
  71         .onDestroy = __vcui_view_incoming_lock_ondestroy,
  72         .priv = NULL,
  73 };
  74
  75 voice_call_view_data_t *_vcui_view_incoming_lock_new(vcui_app_call_data_t *ad)
  76 {
  77
  78         s_view.app_data = ad;
  79         s_view.priv = calloc(1, sizeof(incoming_lock_view_priv_t));
  80
  81         if (!s_view.priv) {
  82                 CALL_UI_DEBUG("ERROR!!!!!!!!!!!");
  83         }
  84
  85         return &s_view;
  86 }
  87
  88 static Evas_Object *__vcui_view_incoming_lock_load_edj(Evas *evas, char *edjname, const char *grpname)
  89 {
  90         Evas_Object *edj;
  91
  92         edj = edje_object_add(evas);
  93         if (!edje_object_file_set(edj, edjname, grpname)) {
  94                 CALL_UI_DEBUG("ERROR!!");
  95                 return NULL;
  96         }
  97
  98         return edj;
  99 }
 100
 101 static void __vcui_view_incoming_lock_accept_cb(void *data, Evas_Object *obj, void *event_info)
 102 {
 103         int all_call_count = 0;
 104         int nostatus_call_count = 0;
 105         int unhold_call_count = 0;
 106         int hold_call_count = 0;
 107
 108         if (_vcui_is_phonelock_status() == EINA_FALSE)
 109                 vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 110
 111         all_call_count = _vcui_doc_get_all_call_data_count();
 112         nostatus_call_count = _vcui_doc_get_no_status_call_data_count();
 113         unhold_call_count = _vcui_doc_get_unhold_call_data_count();
 114         hold_call_count = _vcui_doc_get_hold_call_data_count();
 115         CALL_UI_DEBUG("all_call_count:%d >>>> nostatus_call_count:%d >>>> unhold_call_count:%d >>>> hold_call_count:%d", \
 116                         all_call_count, nostatus_call_count, unhold_call_count, hold_call_count);
 117
 118         if (unhold_call_count == 0) {
 119                 CALL_UI_DEBUG("No Call Or Held call - Accept");
 120                 vcall_engine_answer_call();
 121         } else {
 122                 CALL_UI_DEBUG("Show popup - 2nd MT call - test volume popup");
 123                 _vcui_view_popup_second_mtcall_load(_("IDS_CALL_HEADER_ACCEPT_CALL_AFTER"), unhold_call_count, hold_call_count);
 124         }
 125 }
 126
 127 static Evas_Object *__vcui_view_incoming_lock_create_accept_btn(Evas_Object *layout)
 128 {
 129         Evas_Object *btn;
 130
 131         Evas_Object *sw = edje_object_part_swallow_get(_EDJ(layout), "btn_accept");
 132         if (sw) {
 133                 edje_object_part_unswallow(_EDJ(layout), sw);
 134                 evas_object_del(sw);
 135         }
 136
 137         btn = elm_button_add(layout);
 138         elm_object_part_content_set(layout, "btn_accept", btn);
 139         elm_object_style_set(btn, "sweep");
 140         elm_object_text_set(btn, _("IDS_CALL_BUTTON_ACCEPT"));
 141         evas_object_smart_callback_add(btn, "clicked", __vcui_view_incoming_lock_accept_cb, NULL);
 142
 143         return btn;
 144 }
 145
 146 static void __vcui_view_incoming_lock_reject_cb(void *data, Evas_Object *obj, void *event_info)
 147 {
 148         vcall_engine_reject_call();
 149 }
 150
 151 static Evas_Object *__vcui_view_incoming_lock_create_reject_btn(Evas_Object *layout)
 152 {
 153         Evas_Object *btn;
 154
 155         Evas_Object *sw = edje_object_part_swallow_get(_EDJ(layout), "btn_reject");
 156         if (sw) {
 157                 edje_object_part_unswallow(_EDJ(layout), sw);
 158                 evas_object_del(sw);
 159         }
 160
 161         btn = elm_button_add(layout);
 162         elm_object_part_content_set(layout, "btn_reject", btn);
 163         elm_object_style_set(btn, "sweep");
 164         elm_object_text_set(btn, _("IDS_CALL_BUTTON_REJECT"));
 165         evas_object_smart_callback_add(btn, "clicked", __vcui_view_incoming_lock_reject_cb, NULL);
 166
 167         return btn;
 168 }
 169
 170 static void __reject_msg_list_param_reset(void *data)
 171 {
 172         CALL_UI_DEBUG("..");
 173         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 174         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 175
 176         priv->y_momentum = 0;
 177         priv->reject_with_msg_start_y = 0;
 178         priv->reject_with_msg_cur_y = 0;
 179         priv->bmouse_down_pressed = EINA_FALSE;
 180 }
 181
 182 static void __reject_screen_transit_complete_cb(void *data, Elm_Transit *transit)
 183 {
 184         CALL_UI_DEBUG("..");
 185         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 186         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 187
 188         if (EINA_FALSE == evas_object_data_get(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY)) {
 189                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-up-arrow", "reject_msg");
 190         } else {
 191                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-down-arrow", "reject_msg");
 192         }
 193
 194         __reject_msg_list_param_reset(vd);
 195
 196         return;
 197 }
 198
 199 static Eina_Bool __rej_msg_show_sliding_effect(void *data)
 200 {
 201         CALL_UI_DEBUG("..");
 202         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 203         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 204         Evas_Object *screen_ly;
 205         Elm_Transit *transit;
 206         int xpos = 0;
 207         int ypos = 0;
 208         int width = 0;
 209         int height = 0;
 210         int transit_y = 0;
 211         int max_height_limit = 0;
 212
 213         screen_ly = priv->lock_reject_with_msg;
 214         transit = elm_transit_add();
 215         elm_transit_object_add(transit, screen_ly);
 216
 217         evas_object_geometry_get(priv->lock_reject_with_msg, &xpos, &ypos, &width, &height);
 218         CALL_UI_DEBUG("reject_w_msg dimensions ---> x[%d] y[%d] w[%d] h[%d]", xpos, ypos, width, height);
 219         CALL_UI_DEBUG("priv->y_momentum: %d", priv->y_momentum);
 220
 221         /*Max height possible*/
 222         max_height_limit = (priv->msg_list_height) * (priv->y_scale_factor);
 223         CALL_UI_DEBUG("max_height_limit: %d", max_height_limit);
 224
 225         if (EINA_FALSE == evas_object_data_get(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY)) {
 226                 CALL_UI_DEBUG("Close list... Check if opening is feasible");
 227
 228                 if (priv->y_momentum) {
 229                         CALL_UI_DEBUG("Momentum...");
 230
 231                         if (priv->y_momentum < -1500) {
 232                                 CALL_UI_DEBUG("Huge Momentum... Move the layout");
 233
 234                                 /*effect to pull up the window.*/
 235                                 transit_y = -(max_height_limit + ypos);
 236
 237                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 238                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 239                         } else {
 240                                 CALL_UI_DEBUG("Small Momentum..");
 241
 242                                 if (ypos != 0) {        /*Reject msg layout is displaced from its original position*/
 243                                         if (-ypos < max_height_limit/2) {       /*Layout position is lesser than half of the height*/
 244                                                 CALL_UI_DEBUG("Movement L.T. HALF the height..");
 245
 246                                                 /*effect to pull down the window.*/
 247                                                 transit_y = -ypos;
 248
 249                                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 250                                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 251                                         } else if (-ypos >= max_height_limit/2 && -ypos <= max_height_limit) {  /*Layout position is greater than half of the height*/
 252                                                 CALL_UI_DEBUG("Movement G.T. HALF the height..");
 253
 254                                                 /*effect to pull up the window.*/
 255                                                 transit_y = -(max_height_limit + ypos);
 256
 257                                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 258                                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 259                                         }
 260                                 }
 261                         }
 262                 } else {
 263                         CALL_UI_DEBUG("NO Momentum... Dont open");
 264
 265                         if (ypos != 0) {        /*Reject msg layout is displaced from its original position*/
 266                                 if (-ypos < max_height_limit/2) {       /*Layout position is lesser than half of the height*/
 267                                         CALL_UI_DEBUG("Movement L.T. HALF the height..");
 268
 269                                         /*effect to pull down the window.*/
 270                                         transit_y = -ypos;
 271
 272                                         elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 273                                         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 274                                 } else if (-ypos >= max_height_limit/2 && -ypos <= max_height_limit) {  /*Layout position is greater than half of the height*/
 275                                         CALL_UI_DEBUG("Movement G.T. HALF the height..");
 276
 277                                         /*effect to pull up the window.*/
 278                                         transit_y = -(max_height_limit + ypos);
 279
 280                                         elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 281                                         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 282                                 }
 283                         }
 284                 }
 285         } else {
 286                 CALL_UI_DEBUG("Open list... Check if closing is feasible");
 287
 288                 if (priv->y_momentum) {
 289                         CALL_UI_DEBUG("Momentum...");
 290
 291                         if (priv->y_momentum > 1500) {
 292                                 CALL_UI_DEBUG("Huge Momentum... Move the layout");
 293
 294                                 /*effect to pull down the window.*/
 295                                 transit_y = -ypos;
 296
 297                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 298                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 299                         } else {
 300                                 CALL_UI_DEBUG("Small Momentum..");
 301
 302                                 if (ypos != 0) {        /*Reject msg layout is displaced from its original position*/
 303                                         if (-ypos < (max_height_limit * 0.8)) { /*Layout position is lesser than 80% of the height*/
 304                                                 CALL_UI_DEBUG("Movement L.T. 80 percent of the height..");
 305
 306                                                 /*effect to pull down the window.*/
 307                                                 transit_y = -ypos;
 308
 309                                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 310                                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 311                                         } else if (-ypos >= (max_height_limit * 0.8) && -ypos <= max_height_limit) {    /*Layout position is greater than half of the height*/
 312                                                 CALL_UI_DEBUG("Movement G.T. 80 percent of the height..");
 313
 314                                                 /*effect to pull up the window.*/
 315                                                 transit_y = -(max_height_limit + ypos);
 316
 317                                                 elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 318                                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 319                                         }
 320                                 }
 321                         }
 322                 } else {
 323                         CALL_UI_DEBUG("NO Momentum... Dont close");
 324
 325                         if (ypos != 0) {        /*Reject msg layout is displaced from its original position*/
 326                                 if (-ypos < (max_height_limit * 0.8)) { /*Layout position is lesser than 80% of the height*/
 327                                         CALL_UI_DEBUG("Movement L.T. 80 percent of the height..");
 328
 329                                         /*effect to pull down the window.*/
 330                                         transit_y = -ypos;
 331
 332                                         elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 333                                         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 334                                 } else if (-ypos >= (max_height_limit * 0.8) && -ypos <= max_height_limit) {    /*Layout position is greater than half of the height*/
 335                                         CALL_UI_DEBUG("Movement G.T. 80 percent of the height..");
 336
 337                                         /*effect to pull up the window.*/
 338                                         transit_y = -(max_height_limit + ypos);
 339
 340                                         elm_transit_effect_translation_add(transit, 0, 0, 0, transit_y);
 341                                         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 342                                 }
 343                         }
 344                 }
 345         }
 346
 347         elm_transit_del_cb_set(transit, __reject_screen_transit_complete_cb, vd);
 348
 349         if (priv->y_momentum < 0)
 350                 priv->y_momentum = -priv->y_momentum;
 351
 352         if (priv->y_momentum < 1500) {
 353                 elm_transit_duration_set(transit, 0.5);
 354         } else if (priv->y_momentum >= 1500 && priv->y_momentum < 3000) {
 355                 elm_transit_duration_set(transit, 0.4);
 356         } else if (priv->y_momentum >= 3000 && priv->y_momentum < 4500) {
 357                 elm_transit_duration_set(transit, 0.3);
 358         } else if (priv->y_momentum >= 4500) {
 359                 elm_transit_duration_set(transit, 0.2);
 360         }
 361         evas_object_show(screen_ly);    /*It must be called before elm_transit_go(). transit policy*/
 362         elm_transit_objects_final_state_keep_set(transit, EINA_TRUE);   /*Keep the window position as end of effect.*/
 363         elm_transit_go(transit);
 364
 365         return ECORE_CALLBACK_CANCEL;
 366 }
 367
 368 static void __vcui_view_incoming_lock_reject_with_msg_mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 369 {
 370         CALL_UI_DEBUG("..");
 371         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 372         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 373         Evas_Event_Mouse_Move *ev = event_info;
 374
 375         priv->reject_with_msg_start_y = ev->cur.canvas.y;
 376         priv->bmouse_down_pressed = EINA_TRUE;
 377 }
 378
 379 static void __vcui_view_incoming_lock_reject_with_msg_mouse_move_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 380 {
 381         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 382         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 383         Evas_Event_Mouse_Move *ev = event_info;
 384         int diff_y = 0;
 385         int max_height_limit = 0;
 386
 387         /*Max height possible*/
 388         max_height_limit = (priv->msg_list_height) * (priv->y_scale_factor);
 389         CALL_UI_DEBUG("max_height_limit: %d", max_height_limit);
 390
 391         if (priv->bmouse_down_pressed) {
 392                 CALL_UI_DEBUG("mouse down was pressed - handle move event");
 393                 priv->reject_with_msg_cur_y = ev->cur.canvas.y;
 394
 395                 diff_y = (priv->reject_with_msg_cur_y - priv->reject_with_msg_start_y) * (priv->y_scale_factor);
 396                 CALL_UI_DEBUG("diff_y [<<< %d >>>>]", diff_y);
 397
 398                 if (EINA_FALSE == evas_object_data_get(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY)) {
 399                         if ((diff_y > -max_height_limit) && (diff_y <= 0)) {
 400                                 /*Lies between 0 and msg-list layout height*/
 401                                 evas_object_move(priv->lock_reject_with_msg, 0, diff_y);
 402                         } else if (diff_y <= -max_height_limit) {
 403                                 /*Special case - Move the max distance - msg-list height*/
 404                                 evas_object_move(priv->lock_reject_with_msg, 0, -max_height_limit);
 405                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_TRUE);
 406                                 __reject_screen_transit_complete_cb(vd, NULL);
 407                         }
 408                 } else {
 409                         if ((diff_y >= 0) && (diff_y < max_height_limit)) {
 410                                 /*Lies between 0 and msg-list layout height*/
 411                                 evas_object_move(priv->lock_reject_with_msg, 0, -(max_height_limit - diff_y));
 412                         } else if (diff_y >= max_height_limit) {
 413                                 /*Special case - Move the max distance - msg-list height*/
 414                                 evas_object_move(priv->lock_reject_with_msg, 0, 0);
 415                                 evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, (const void *)EINA_FALSE);
 416                                 __reject_screen_transit_complete_cb(vd, NULL);
 417                         }
 418                 }
 419         } else {
 420                 CALL_UI_DEBUG("mouse down was NOT pressed - DONT handle move event");
 421         }
 422 }
 423
 424 static void __vcui_view_incoming_lock_reject_with_msg_mouse_up_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 425 {
 426         CALL_UI_DEBUG("..");
 427         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 428         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 429
 430         if (priv->bmouse_down_pressed) {
 431                 ecore_idler_add(__rej_msg_show_sliding_effect, vd);
 432         } else {
 433                 CALL_UI_DEBUG("mouse down was NOT pressed - DONT handle up event");
 434         }
 435 }
 436
 437 static void __send_reject_msg_status_cb(msg_handle_t Handle, msg_struct_t pStatus, void *pUserParam)
 438 {
 439         VCUI_RETURN_IF_FAIL(pStatus != NULL);
 440         int status = MSG_NETWORK_SEND_FAIL;
 441
 442         msg_get_int_value(pStatus, MSG_SENT_STATUS_NETWORK_STATUS_INT, &status);
 443         CALL_UI_DEBUG("status:[%d]", status);
 444         if (status != MSG_NETWORK_SEND_SUCCESS) {
 445                 CALL_UI_DEBUG("..");
 446                 _vcui_view_popup_replace(_("IDS_MSGC_POP_SENDINGFAILED"), POPUP_TIMEOUT_SHORT, EINA_TRUE);
 447         }
 448 }
 449
 450 static Eina_Bool __send_reject_msg_on_idle(void *data)
 451 {
 452         VCUI_RETURN_FALSE_IF_FAIL(data != NULL);
 453
 454         CALL_UI_DEBUG("..");
 455         voice_call_view_data_t *vd = data;
 456         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 457         call_data_t *call_data = NULL;
 458
 459         msg_error_t err = MSG_SUCCESS;
 460         msg_handle_t msgHandle = NULL;
 461
 462         call_data = _vcui_doc_get_recent_mt_call_data();
 463         if (call_data == NULL) {
 464                 CALL_UI_DEBUG("call data is null");
 465                 return EINA_FALSE;
 466         }
 467
 468         err = msg_open_msg_handle(&msgHandle);
 469         if (err != MSG_SUCCESS) {
 470                 CALL_UI_DEBUG("msg_open_msg_handle()- failed [%d]", err);
 471                 return EINA_FALSE;
 472         }
 473
 474         err = msg_reg_sent_status_callback(msgHandle, &__send_reject_msg_status_cb, NULL);
 475         if (err != MSG_SUCCESS) {
 476                 CALL_UI_DEBUG("msg_reg_sent_status_callback()- failed [%d]", err);
 477                 msg_close_msg_handle(&msgHandle);
 478                 return EINA_FALSE;
 479         }
 480         msg_struct_t msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 481         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 482         msg_struct_t pReq = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
 483
 484         /* Set message type to SMS reject*/
 485         msg_set_int_value(msgInfo, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS_REJECT);
 486
 487         /* No setting send option */
 488         msg_set_bool_value(sendOpt, MSG_SEND_OPT_SETTING_BOOL, FALSE);
 489
 490         /* Set message body */
 491         if (msg_set_str_value(msgInfo, MSG_MESSAGE_SMS_DATA_STR, priv->reject_msg, strlen(priv->reject_msg))!= MSG_SUCCESS)     {
 492                 return EINA_FALSE;
 493         }
 494
 495         /* Create address list*/
 496         msg_struct_list_s *addr_list;
 497         msg_get_list_handle(msgInfo, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 498         msg_struct_t addr_info = addr_list->msg_struct_info[0];
 499         char *call_number = _vcui_doc_get_call_number(call_data);
 500
 501         /* Set message address */
 502         msg_set_int_value(addr_info, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, MSG_RECIPIENTS_TYPE_TO);
 503         msg_set_str_value(addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, call_number, strlen(call_number));
 504         addr_list->nCount = 1;
 505
 506         /* Set message struct to Request*/
 507         msg_set_struct_handle(pReq, MSG_REQUEST_MESSAGE_HND, msgInfo);
 508         msg_set_struct_handle(pReq, MSG_REQUEST_SENDOPT_HND, sendOpt);
 509
 510         /* Send message */
 511         err = msg_sms_send_message(msgHandle, pReq);
 512         if (err != MSG_SUCCESS) {
 513                 CALL_UI_DEBUG("msg_sms_send_message() - failed [%d]", err);
 514                 msg_close_msg_handle(&msgHandle);
 515                 _vcui_view_popup_replace(_("IDS_MSGC_POP_SENDINGFAILED"), POPUP_TIMEOUT_SHORT, EINA_TRUE);
 516         } else {
 517                 CALL_UI_DEBUG("Sending...");
 518         }
 519
 520         msg_release_struct(&pReq);
 521         msg_release_struct(&msgInfo);
 522         msg_release_struct(&sendOpt);
 523
 524         return EINA_FALSE;
 525 }
 526
 527 static char *__reject_list_get_msg_by_index(void *data, int index)
 528 {
 529         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 530         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 531
 532         char *ret_str = NULL;
 533
 534         if (priv->msg_func_ptr) {
 535                 ret_str = (char *) priv->msg_func_ptr(index);  /* i : reject msg index(0 ~ 4)*/
 536                 CALL_UI_DEBUG("ret_str(%s)", ret_str);
 537         }
 538
 539         return ret_str;
 540 }
 541
 542 static char *__reject_msg_gl_label_get_msg(void *data, Evas_Object *obj, const char *part)
 543 {
 544         VCUI_RETURN_NULL_IF_FAIL(part != NULL);
 545         CALL_UI_DEBUG("..");
 546         voice_call_view_data_t *vd = (voice_call_view_data_t *)evas_object_data_get(obj, REJ_MSG_GENLIST_DATA);
 547
 548         int index = (int)data;
 549         CALL_UI_DEBUG("index: %d", index);
 550         char *entry_label = NULL;
 551         char *msg_str = NULL;
 552
 553         if (!strcmp(part, "elm.text")) {
 554                 if (index != -1) {
 555                         msg_str = __reject_list_get_msg_by_index(vd, index);
 556                         CALL_UI_DEBUG("msg_str(%s)", msg_str);
 557
 558                         if (msg_str != NULL) {
 559                                 entry_label = elm_entry_markup_to_utf8(msg_str);
 560                                 if (entry_label == NULL) {
 561                                         free(msg_str);
 562                                         msg_str = NULL;
 563                                         return NULL;
 564                                 }
 565                                 free(msg_str);
 566                                 msg_str = NULL;
 567                                 return entry_label;
 568                         }
 569                 } else {
 570                         CALL_UI_DEBUG("..");
 571                         msg_str = _("No message");
 572                         return strdup(msg_str);
 573                 }
 574         }
 575
 576         return NULL;
 577 }
 578
 579 static void __reject_msg_send_btn_cb(void *data, Evas_Object *obj, void *event_info)
 580 {
 581         VCUI_RETURN_IF_FAIL(data != NULL);
 582         CALL_UI_DEBUG("..");
 583
 584         char *ret_str = NULL;
 585         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 586         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 587         int index = (int)evas_object_data_get(obj, REJ_MSG_GENLIST_INDEX);
 588
 589         ret_str =  __reject_list_get_msg_by_index(vd, index);
 590         if (ret_str) {
 591                 snprintf(priv->reject_msg, sizeof(priv->reject_msg), "%s", ret_str);
 592                 free(ret_str);
 593         }
 594
 595         vcall_engine_reject_call();
 596
 597         ecore_timer_add(TIMER_TIMEOUT_0_3_SEC, __send_reject_msg_on_idle, vd);
 598 }
 599
 600 static Evas_Object *__reject_msg_gl_content_get_msg(void *data, Evas_Object *obj, const char *part)
 601 {
 602         CALL_UI_DEBUG("..");
 603
 604         Evas_Object *button;
 605         int index = (int)data;
 606         CALL_UI_DEBUG("index: %d", index);
 607
 608         if (!strcmp(part, "elm.swallow.end")) {
 609                 if (index != -1) {
 610                         voice_call_view_data_t *vd = (voice_call_view_data_t *)evas_object_data_get(obj, REJ_MSG_GENLIST_DATA);
 611                         button = elm_button_add(obj);
 612                         evas_object_data_set(button, REJ_MSG_GENLIST_INDEX, data);
 613                         elm_object_text_set(button, dgettext("sys_string", "IDS_COM_SK_SEND"));
 614                         evas_object_propagate_events_set(button, EINA_FALSE);
 615                         evas_object_smart_callback_add(button, "clicked", __reject_msg_send_btn_cb, vd);
 616                         return button;
 617                 } else {
 618                         CALL_UI_DEBUG("do nothing for index [%d]", index);
 619                 }
 620         }
 621
 622         return NULL;
 623 }
 624
 625 static void __reject_msg_gl_sel_msg(void *data, Evas_Object *obj, void *event_info)
 626 {
 627         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 628 }
 629
 630 static Evas_Event_Flags __reject_msg_flick_gesture_move_event_cb(void *data, void *event_info)
 631 {
 632         CALL_UI_DEBUG("Flick_Gesture Move");
 633         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 634         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 635         Elm_Gesture_Line_Info *info = (Elm_Gesture_Line_Info *)event_info;
 636
 637         CALL_UI_DEBUG("*********************************************");
 638         CALL_UI_DEBUG("info->angle = %lf", info->angle);
 639         CALL_UI_DEBUG("info->momentum.mx = %d, info->momentum.my = %d", info->momentum.mx, info->momentum.my);
 640         CALL_UI_DEBUG("info->momentum.n = %d", info->momentum.n);
 641         CALL_UI_DEBUG("info->momentum.tx = %d, info->momentum.ty = %d", info->momentum.tx, info->momentum.ty);
 642         CALL_UI_DEBUG("info->momentum.x1 = %d, info->momentum.x2 = %d", info->momentum.x1, info->momentum.x2);
 643         CALL_UI_DEBUG("info->momentum.y1 = %d, info->momentum.y2 = %d", info->momentum.y1, info->momentum.y2);
 644         CALL_UI_DEBUG("*********************************************");
 645
 646         priv->y_momentum = info->momentum.my;
 647
 648         return EVAS_EVENT_FLAG_NONE;
 649 }
 650
 651 static void __reject_msg_back_cb(void *data, Evas_Object *obj, void *event_info)
 652 {
 653         CALL_UI_DEBUG("..");
 654         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 655         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 656
 657         if (NULL == vd) {
 658                 CALL_UI_DEBUG("view data is NULL");
 659                 return;
 660         }
 661         evas_object_move(priv->lock_reject_with_msg, 0, 0);
 662         edje_object_signal_emit(priv->lock_reject_with_msg, "show-up-arrow", "reject_msg");
 663         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, EINA_FALSE);
 664
 665 }
 666
 667 static void __create_new_msg_cb(void *data, Evas_Object *obj, void *event_info)
 668 {
 669         VCUI_RETURN_IF_FAIL(data != NULL);
 670         CALL_UI_DEBUG("..");
 671
 672         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 673         char *tel_number = NULL;
 674         call_data_t *call_data = NULL;
 675
 676         vcall_engine_reject_call();
 677
 678         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 679
 680         call_data = _vcui_doc_get_recent_mt_call_data();
 681         if (call_data == NULL) {
 682                 CALL_UI_DEBUG("call data is null");
 683                 return;
 684         }
 685         tel_number = _vcui_doc_get_call_number(call_data);
 686         _vcui_doc_launch_msg_composer(vd, tel_number);
 687 }
 688
 689 static void __reject_msg_create_call_setting_handle(void *data)
 690 {
 691         CALL_UI_DEBUG("..");
 692         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 693         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 694         char *error = NULL;
 695
 696         priv->dl_handle = dlopen(VCUI_CST_SO_PATH, RTLD_LAZY);
 697         if (priv->dl_handle) {
 698                 priv->msg_func_ptr = dlsym(priv->dl_handle, VCUI_CST_REJECT_MSG_GET);
 699                 if ((error = dlerror()) != NULL) {
 700                         CALL_UI_DEBUG("dlsym failed!!! error = %s", error);
 701                         priv->msg_func_ptr = NULL;
 702                         dlclose(priv->dl_handle);
 703                         priv->dl_handle = NULL;
 704                 }
 705         } else {
 706                 CALL_UI_DEBUG("failed to open libug-setting-call-efl.so");
 707         }
 708 }
 709
 710 static void __reject_msg_list_height_update(void *data, int msg_cnt)
 711 {
 712         CALL_UI_DEBUG("..");
 713         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 714         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 715
 716         CALL_UI_DEBUG("msg_cnt[%d]", msg_cnt);
 717
 718         switch (msg_cnt) {
 719         case 0:
 720         case 1:
 721                 priv->msg_list_height = MTLOCK_REJECT_MSG_ONE_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 722                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-one-line", "reject-list");
 723                 break;
 724         case 2:
 725                 priv->msg_list_height = MTLOCK_REJECT_MSG_TWO_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 726                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-two-line", "reject-list");
 727                 break;
 728         case 3:
 729                 priv->msg_list_height = MTLOCK_REJECT_MSG_THREE_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 730                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-three-line", "reject-list");
 731                 break;
 732         case 4:
 733                 priv->msg_list_height = MTLOCK_REJECT_MSG_FOUR_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 734                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-four-line", "reject-list");
 735                 break;
 736         case 5:
 737                 priv->msg_list_height = MTLOCK_REJECT_MSG_FIVE_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 738                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-five-line", "reject-list");
 739                 break;
 740         case 6:
 741                 priv->msg_list_height = MTLOCK_REJECT_MSG_SIX_LINE_LIST_HEIGHT+MTLOCK_REJECT_MSG_TOOLBAR_HEIGHT;
 742                 edje_object_signal_emit(priv->lock_reject_with_msg, "show-six-line", "reject-list");
 743                 break;
 744         default:
 745                 break;
 746         }
 747 }
 748
 749 static void __reject_msg_create_glist(void *data)
 750 {
 751         CALL_UI_DEBUG("..");
 752         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 753         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 754         int msg_cnt = 0;
 755         int index = 0;
 756
 757         /* msg count from setting */
 758         vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &msg_cnt);
 759         CALL_UI_DEBUG("msg_cnt: %d", msg_cnt);
 760
 761         /* create gen list */
 762         priv->msg_glist = elm_genlist_add(priv->lock_reject_with_msg);
 763         evas_object_data_set(priv->msg_glist, REJ_MSG_GENLIST_DATA, (const void *)vd);
 764         evas_object_size_hint_weight_set(priv->msg_glist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 765         evas_object_size_hint_align_set(priv->msg_glist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 766         edje_object_part_swallow(priv->lock_reject_with_msg, "swl_msglist", priv->msg_glist);
 767
 768         priv->itc_reject_msg = elm_genlist_item_class_new();
 769
 770         priv->itc_reject_msg->item_style = "call/reject_msg";
 771         priv->itc_reject_msg->func.text_get = __reject_msg_gl_label_get_msg;
 772         priv->itc_reject_msg->func.content_get = __reject_msg_gl_content_get_msg;
 773         priv->itc_reject_msg->func.state_get = NULL;
 774         priv->itc_reject_msg->func.del = NULL;
 775
 776         if (msg_cnt == 0 ) {
 777                 index = -1;
 778                 elm_genlist_item_append(priv->msg_glist, priv->itc_reject_msg, (void *)index, NULL, ELM_GENLIST_ITEM_NONE, __reject_msg_gl_sel_msg, NULL);
 779         } else {
 780                 for (index = 0; index < msg_cnt; index++) {
 781                         elm_genlist_item_append(priv->msg_glist, priv->itc_reject_msg, (void *)index, NULL, ELM_GENLIST_ITEM_NONE, __reject_msg_gl_sel_msg, NULL);
 782                 }
 783         }
 784
 785         /*Adjust the list height*/
 786         __reject_msg_list_height_update(vd, msg_cnt);
 787 }
 788
 789 static void __reject_msg_create_gesture_layer(void *data)
 790 {
 791         CALL_UI_DEBUG("..");
 792         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 793         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 794         Evas_Object *rej_msg_gesture_layer = NULL;
 795         Evas_Object *rej_msg_bg = NULL;
 796
 797         rej_msg_bg = (Evas_Object *)edje_object_part_object_get(priv->lock_reject_with_msg, "reject_msg_bg");
 798         rej_msg_gesture_layer = elm_gesture_layer_add(priv->lock_reject_with_msg);
 799         if (FALSE == elm_gesture_layer_attach(rej_msg_gesture_layer, (Evas_Object *)rej_msg_bg)) {
 800                 CALL_UI_DEBUG("elm_gesture_layer_attach failed !!");
 801                 evas_object_del(rej_msg_gesture_layer);
 802                 rej_msg_gesture_layer = NULL;
 803         } else {
 804                 elm_gesture_layer_cb_set(rej_msg_gesture_layer, ELM_GESTURE_N_FLICKS, ELM_GESTURE_STATE_MOVE, __reject_msg_flick_gesture_move_event_cb, vd);
 805         }
 806 }
 807
 808 static void __reject_msg_create_toolbar(void *data)
 809 {
 810         CALL_UI_DEBUG("..");
 811         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 812         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 813         Evas_Object *rej_msg_toolbar = NULL;
 814         Evas_Object *btn = NULL;
 815         Elm_Object_Item *item = NULL;
 816
 817         rej_msg_toolbar = elm_toolbar_add(priv->lock_reject_with_msg);
 818         elm_toolbar_homogeneous_set(rej_msg_toolbar, TRUE);
 819         elm_toolbar_shrink_mode_set(rej_msg_toolbar, ELM_TOOLBAR_SHRINK_EXPAND);
 820         elm_toolbar_item_append(rej_msg_toolbar, REJ_MSG_CREATE_ICON, NULL, __create_new_msg_cb, vd);
 821         item = elm_toolbar_item_append(rej_msg_toolbar, NULL, NULL, NULL, NULL);
 822         elm_object_item_disabled_set(item, EINA_TRUE);
 823         item = elm_toolbar_item_append(rej_msg_toolbar, NULL, NULL, NULL, NULL);
 824         elm_object_item_disabled_set(item, EINA_TRUE);
 825         item = elm_toolbar_item_append(rej_msg_toolbar, NULL, NULL, NULL, NULL);
 826         btn = elm_button_add(rej_msg_toolbar);
 827         elm_object_style_set(btn, "naviframe/back_btn/default");
 828         evas_object_smart_callback_add(btn, "clicked", __reject_msg_back_cb, vd);
 829         elm_object_item_content_set(item, btn);
 830         edje_object_part_swallow(priv->lock_reject_with_msg, "swl_msgtoolbar", rej_msg_toolbar);
 831 }
 832
 833 static Evas_Object *__vcui_view_incoming_lock_create_reject_msg_layout(void *data)
 834 {
 835         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 836         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 837         vcui_app_call_data_t *ad = vd->app_data;
 838         Evas_Object *rej_msg_bg = NULL;
 839
 840         if (priv->lock_reject_with_msg != NULL) {
 841                 evas_object_del(priv->lock_reject_with_msg);
 842                 priv->lock_reject_with_msg = NULL;
 843         }
 844         priv->lock_reject_with_msg = __vcui_view_incoming_lock_load_edj(evas_object_evas_get(ad->win_main), EDJ_NAME, GRP_LOCK_REJECT_WITH_MSG);
 845         evas_object_resize(priv->lock_reject_with_msg, ad->root_w, ad->root_h);
 846
 847         __reject_msg_create_call_setting_handle(vd);
 848
 849         __reject_msg_create_glist(vd);
 850
 851         __reject_msg_create_gesture_layer(vd);
 852
 853         __reject_msg_create_toolbar(vd);
 854
 855         rej_msg_bg = (Evas_Object *)edje_object_part_object_get(priv->lock_reject_with_msg, "reject_msg_bg");
 856         evas_object_event_callback_add(rej_msg_bg, EVAS_CALLBACK_MOUSE_DOWN, __vcui_view_incoming_lock_reject_with_msg_mouse_down_cb, vd);
 857         evas_object_event_callback_add(rej_msg_bg, EVAS_CALLBACK_MOUSE_MOVE, __vcui_view_incoming_lock_reject_with_msg_mouse_move_cb, vd);
 858         evas_object_event_callback_add(rej_msg_bg, EVAS_CALLBACK_MOUSE_UP, __vcui_view_incoming_lock_reject_with_msg_mouse_up_cb, vd);
 859
 860         edje_object_part_text_set(priv->lock_reject_with_msg, "reject_msg_text", _("IDS_VCALL_BUTTON_REJECT_WITH_MESSAGE"));
 861         edje_object_signal_emit(priv->lock_reject_with_msg, "show-up-arrow", "reject_msg");
 862         evas_object_data_set(priv->lock_reject_with_msg, REJ_MSG_LIST_OPEN_STATUS_KEY, EINA_FALSE);
 863
 864         __reject_msg_list_param_reset(vd);
 865
 866         evas_object_show(priv->lock_reject_with_msg);
 867
 868         return priv->lock_reject_with_msg;
 869 }
 870
 871 static void __vcui_view_incoming_lock_draw_screen(voice_call_view_data_t *vd)
 872 {
 873         CALL_UI_DEBUG("..");
 874
 875         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 876         Evas_Object *eo = priv->contents;
 877         vcui_app_call_data_t *ad = vd->app_data;
 878
 879         call_data_t *call_data = _vcui_doc_get_recent_mt_call_data();
 880         if (call_data == NULL) {
 881                 CALL_UI_DEBUG("call data is null");
 882                 return;
 883         }
 884         if (_vcui_doc_get_call_type(call_data) != CALL_INCOMING) {
 885                 CALL_UI_DEBUG("it is not call_incoming.");
 886                 return;
 887         }
 888
 889         char *file_path = _vcui_doc_get_caller_id_file_path(call_data);
 890
 891         /* call image */
 892         _vcui_delete_contact_image(priv->contents);
 893         if (strcmp(file_path, NOIMG_ICON) == 0) {
 894                 _vcui_show_wallpaper_image(priv->contents);
 895         } else {
 896                 CALL_UI_DEBUG("Caller ID file_path: %s", file_path);
 897                 {
 898                         _vcui_show_wallpaper_image(priv->contents);
 899                         priv->ic = _vcui_show_contact_image(priv->contents, vd->app_data->win_main, file_path);
 900                 }
 901         }
 902         _vcui_show_call_bg_img(priv->contents);
 903
 904         char *call_number = _vcui_doc_get_call_number(call_data);
 905         char *call_name = _vcui_doc_get_call_display_name(call_data);
 906         /* call name (if nothing, call number) */
 907         if (strlen(call_name) == 0) {
 908                 _vcui_show_caller_info_name(vd, call_number, EINA_FALSE);
 909         } else {
 910                 _vcui_show_caller_info_name(vd, call_name, EINA_FALSE);
 911                 _vcui_show_caller_info_number(vd, call_number, EINA_FALSE);
 912         }
 913
 914         _vcui_show_caller_info_icon(vd, EINA_FALSE);
 915         _vcui_show_caller_info_status(vd, dgettext("sys_string", "IDS_COM_BODY_VOICE_CALL"), EINA_FALSE);
 916
 917         __vcui_view_incoming_lock_create_accept_btn(priv->contents);
 918         __vcui_view_incoming_lock_create_reject_btn(priv->contents);
 919
 920         if (!(_vcui_is_phonelock_status() == EINA_TRUE)) {
 921                 if (strlen(call_number) > 0) {
 922                         __vcui_view_incoming_lock_create_reject_msg_layout(vd);
 923                 }
 924         }
 925         ad->beffect_needed = EINA_TRUE;
 926
 927         evas_object_show(eo);
 928
 929 }
 930
 931 static Evas_Object *__vcui_view_incoming_lock_create_contents(void *data, char *grpname)
 932 {
 933         if (data == NULL) {
 934                 CALL_UI_DEBUG("ERROR");
 935                 return NULL;
 936         }
 937         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 938         Evas_Object *eo;
 939
 940         /* load edje */
 941         eo = _vcui_load_edj(vd->app_data->win_main, EDJ_NAME, grpname);
 942         if (eo == NULL)
 943                 return NULL;
 944
 945         return eo;
 946 }
 947
 948 static Evas_Object *__vcui_view_incoming_lock_create_layout_main(Evas_Object *parent)
 949 {
 950         if (parent == NULL) {
 951                 CALL_UI_DEBUG("ERROR");
 952                 return NULL;
 953         }
 954
 955         Evas_Object *ly;
 956         ly = elm_layout_add(parent);
 957         retvm_if(ly == NULL, NULL, "Failed elm_layout_add.");
 958
 959         elm_layout_theme_set(ly, "standard", "window", "integration");
 960         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 961         elm_win_resize_object_add(parent, ly);
 962
 963         edje_object_signal_emit(_EDJ(ly), "elm,state,show,indicator", "elm");
 964         edje_object_signal_emit(_EDJ(ly), "elm,state,show,content", "elm");
 965         evas_object_show(ly);
 966
 967         return ly;
 968 }
 969
 970 static int __vcui_view_incoming_lock_oncreate(voice_call_view_data_t *view_data, int param1, void *param2, void *param3)
 971 {
 972         CALL_UI_DEBUG("mt-lock view create!!");
 973
 974         vcui_app_call_data_t *ad = view_data->app_data;
 975         incoming_lock_view_priv_t *priv = view_data->priv;
 976
 977         evas_object_pointer_mode_set(ad->win_main, EVAS_OBJECT_POINTER_MODE_NOGRAB);
 978         if (!view_data->layout) {
 979                 view_data->layout = __vcui_view_incoming_lock_create_layout_main(ad->win_main);
 980                 if (view_data->layout == NULL) {
 981                         CALL_UI_DEBUG("ERROR");
 982                         return VC_ERROR;
 983                 }
 984                 priv->contents = __vcui_view_incoming_lock_create_contents(view_data, GRP_MTLOCK);
 985                 elm_object_part_content_set(view_data->layout, "elm.swallow.content", priv->contents);
 986
 987                 priv->caller_info = __vcui_view_incoming_lock_create_contents(view_data, GRP_CALLER_INFO);
 988                 elm_object_part_content_set(priv->contents, "caller_info", priv->caller_info);
 989
 990                 evas_object_name_set(priv->contents, VIEW_INCOMING_LOCK_LAYOUT_ID);
 991                 CALL_UI_DEBUG("[========== INCOMINGLOCKVIEW: priv->contents Addr : [%p] ==========]", priv->contents);
 992
 993         }
 994
 995         __vcui_view_incoming_lock_onshow(view_data);
 996         return VC_NO_ERROR;
 997 }
 998
 999 static int __vcui_view_incoming_lock_onupdate(voice_call_view_data_t *view_data, void *update_data1, void *update_data2)
1000 {
1001         CALL_UI_DEBUG("mt-lock view update!!");
1002
1003         __vcui_view_incoming_lock_onshow(view_data);
1004         return VC_NO_ERROR;
1005 }
1006
1007 static int __vcui_view_incoming_lock_onhide(voice_call_view_data_t *view_data)
1008 {
1009         CALL_UI_DEBUG("mt-lock view hide!!");
1010
1011         evas_object_hide(view_data->layout);
1012         return VC_NO_ERROR;
1013 }
1014
1015 static int __vcui_view_incoming_lock_onshow(voice_call_view_data_t *view_data)
1016 {
1017         CALL_UI_DEBUG("mt-lock view show!!");
1018         vcui_app_call_data_t *ad = _vcui_get_app_data();
1019         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)view_data->priv;
1020         int result = 0;
1021
1022         /*change the orientation to normal - 0*/
1023         elm_win_rotation_with_resize_set(view_data->app_data->win_main, 0);
1024         elm_win_rotation_with_resize_set(view_data->app_data->popup_mw, 0);
1025
1026         if (ad->root_w == MAIN_WIN_HD_W && ad->root_h == MAIN_WIN_HD_H) {
1027                 priv->y_scale_factor = 1;
1028         } else if (ad->root_w == MAIN_WIN_WVGA_W && ad->root_h == MAIN_WIN_WVGA_H) {
1029                 priv->y_scale_factor = (double) MAIN_WIN_WVGA_H/MAIN_WIN_HD_H;
1030         }
1031         CALL_UI_DEBUG("y_scale_factor %f", priv->y_scale_factor);
1032
1033         __vcui_view_incoming_lock_draw_screen(view_data);
1034
1035         evas_object_hide(view_data->layout);
1036         evas_object_show(view_data->layout);
1037         _vcui_app_win_set_noti_type(EINA_TRUE);
1038
1039         result = utilx_grab_key(ad->disp, ad->win, KEY_POWER, TOP_POSITION_GRAB);
1040         if (result)
1041                 CALL_UI_DEBUG("KEY_VOLUMEUP key grab failed");
1042
1043         result = utilx_grab_key(ad->disp, ad->win, KEY_SELECT, TOP_POSITION_GRAB);
1044         if (result)
1045                 CALL_UI_DEBUG("KEY_VOLUMEUP key grab failed");
1046
1047         return VC_NO_ERROR;
1048 }
1049
1050 static int __vcui_view_incoming_lock_ondestroy(voice_call_view_data_t *view_data)
1051 {
1052         CALL_UI_DEBUG("mt-lock view destroy!!");
1053
1054         vcui_app_call_data_t *ad = _vcui_get_app_data();
1055
1056         voice_call_view_data_t *vd = ad->view_st[VIEW_INCOMING_LOCK_VIEW];
1057         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
1058
1059         if (_vcui_is_idle_lock() == CALL_LOCK)
1060                 _vcui_app_win_set_noti_type(EINA_TRUE);
1061         else
1062                 _vcui_app_win_set_noti_type(EINA_FALSE);
1063
1064         ad->bmute_ringtone = EINA_FALSE;
1065         if (priv != NULL) {
1066
1067                 if (priv->itc_reject_msg) {
1068                         elm_genlist_item_class_free(priv->itc_reject_msg);
1069                         priv->itc_reject_msg = NULL;
1070                 }
1071                 if (priv->lock_reject_with_msg) {
1072                         evas_object_del(priv->lock_reject_with_msg);
1073                         priv->lock_reject_with_msg = NULL;
1074                 }
1075                 if (priv->caller_info) {
1076                         evas_object_del(priv->caller_info);
1077                         priv->caller_info = NULL;
1078                 }
1079
1080                 if (priv->contents) {
1081                         evas_object_del(priv->contents);
1082                         priv->contents = NULL;
1083                 }
1084
1085                 free(priv);
1086                 priv = NULL;
1087         }
1088
1089         if (vd->layout != NULL) {
1090                 evas_object_hide(vd->layout);
1091                 evas_object_del(vd->layout);
1092                 vd->layout = NULL;
1093         }
1094
1095         ad->view_st[VIEW_INCOMING_LOCK_VIEW] = NULL;
1096
1097         _vcui_cache_flush();
1098
1099         utilx_ungrab_key(ad->disp, ad->win, KEY_SELECT);
1100         utilx_ungrab_key(ad->disp, ad->win, KEY_POWER);
1101
1102         return VC_NO_ERROR;
1103 }
1104
1105 int     _vc_ui_view_incoming_lock_check_valid_eo(voice_call_view_data_t *vd)
1106 {
1107         CALL_UI_DEBUG("..");
1108
1109         incoming_lock_view_priv_t *priv = NULL;
1110         int valid = -1;
1111
1112         VCUI_RETURN_VALUE_IF_FAIL(vd , -1);
1113         priv = (incoming_lock_view_priv_t *) vd->priv;
1114
1115         valid = _vcui_check_valid_eo(priv->contents, VIEW_INCOMING_LOCK_LAYOUT_ID);
1116
1117         return valid;
1118 }
1119
1120 Evas_Object *_vc_ui_view_incoming_lock_get_caller_info(voice_call_view_data_t *vd)
1121 {
1122         CALL_UI_DEBUG("..");
1123         incoming_lock_view_priv_t *priv = NULL;
1124
1125         VCUI_RETURN_NULL_IF_FAIL(vd);
1126         priv = (incoming_lock_view_priv_t *) vd->priv;
1127
1128         VCUI_RETURN_NULL_IF_FAIL(priv);
1129         return priv->caller_info;
1130 }
1131
1132 Evas_Object *_vc_ui_view_incoming_lock_get_layout(voice_call_view_data_t *vd)
1133 {
1134         CALL_UI_DEBUG("..");
1135         incoming_lock_view_priv_t *priv = NULL;
1136
1137         VCUI_RETURN_NULL_IF_FAIL(vd);
1138         priv = (incoming_lock_view_priv_t *) vd->priv;
1139
1140         VCUI_RETURN_NULL_IF_FAIL(priv);
1141         return priv->contents;
1142 }