phone-lock-common/src/phone-lock-view.c

   1 /*
   2  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * This file is part of <phone-lock>
   5  * Written by <Seungtaek Chung> <seungtaek.chung@samsung.com>, <Mi-Ju Lee> <miju52.lee@samsung.com>, <Xi Zhichan> <zhichan.xi@samsung.com>
   6  *
   7  * PROPRIETARY/CONFIDENTIAL
   8  *
   9  * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
  10  * You shall not disclose such Confidential Information and shall use it only in accordance
  11  * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
  12  * SAMSUNG make no representations or warranties about the suitability of the software,
  13  * either express or implied, including but not limited to the implied warranties of merchantability,
  14  * fitness for a particular purpose, or non-infringement.
  15  * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
  16  * modifying or distributing this software or its derivatives.
  17  *
  18  */
  19
  20 #include <Ecore_X.h>
  21 #include <vconf.h>
  22 #include <appcore-common.h>
  23 #include <unicode/uloc.h>
  24 #include <unicode/udat.h>
  25 #include <unicode/udatpg.h>
  26 #include <unicode/ustring.h>
  27 #include <heynoti.h>
  28
  29 #include "phone-lock-util.h"
  30 #include "phone-lock-view.h"
  31 #include "phone-lock-string.h"
  32 #include "phone-lock-verification.h"
  33
  34 #ifndef EDJDIR
  35 #define EDJDIR "/opt/apps/org.tizen.phone-lock/res/edje"
  36 #endif
  37
  38 #ifndef IMAGEDIR
  39 #define IMAGEDIR "/opt/apps/org.tizen.phone-lock/res/images"
  40 #endif
  41
  42 #define EDJ_PHONE_LOCK_VIEW EDJDIR"/phone-lock-view.edj"
  43 #define EDJ_PHONE_LOCK_VIEW_ENTRY EDJDIR"/phone-lock-view-entry.edj"
  44 #define PHONE_LOCK_VIEW_DEFAULT_BG_PATH "/opt/share/settings/Wallpapers/Home_default.png"
  45
  46 #define PHONE_LOCK_VIEW_ARROW_DEFAULT_IMG IMAGEDIR"/B07_event_action_emergency_arrow.png"
  47 #define PHONE_LOCK_VIEW_ARROW_PRESS_IMG IMAGEDIR"/B07_event_action_emergency_arrow_press.png"
  48 #define PHONE_LOCK_VIEW_EMERGENCY_CALL_IMG IMAGEDIR"/B07_event_action_emergency.png"
  49
  50 #define VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT   VCONFKEY_SETAPPL_PREFIX"/phone_lock_attempts_left"
  51 #define VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR       VCONFKEY_SETAPPL_PREFIX"/phone_lock_timestamp"
  52
  53 #define PHONE_LOCK_VIEW_PHONE_LOCK_BLOCK_SECONDS 30
  54 #define PHONE_LOCK_VIEW_PHONE_LOCK_ATTEMPTS_MAX  5
  55 #define PHONE_LOCK_VIEW_PHONE_LOCK_TIMESTAMP_STR_LENGTH 200
  56 #define PHONE_LOCK_VIEW_MAIN_W 720
  57 #define PHONE_LOCK_VIEW_MAIN_H 1280
  58
  59 #define _EDJ(o)  elm_layout_edje_get(o)
  60
  61 #define SYSTEM_RESUME "system_wakeup"
  62
  63 struct _phone_lock_view_data {
  64         Evas_Object *win_main;
  65         Evas_Object *layout_main;
  66         Evas_Object *input;
  67         Evas_Object *input_label;
  68         Evas_Object *title_label;
  69         Evas_Object *input_entry;
  70         Evas_Object *background;
  71         Evas_Object *sp_label1;
  72         Evas_Object *sp_label2;
  73         Evas_Object *sp_label3;
  74         Evas_Object *sp_label4;
  75         Evas_Object *editfield_layout;
  76         Evas_Object *event;
  77         Evas_Object *ev;
  78         Evas_Object *info;
  79
  80         int win_w;
  81         int win_h;
  82         int block_seconds;
  83         int view_disabled;
  84
  85         double scale;
  86
  87         Eina_Bool is_customedentry_clicked;
  88         Eina_Bool is_callug_launched;
  89         Eina_Bool is_right_password;
  90         Eina_Bool is_simple_pw_checking;
  91
  92         Evas_Coord drx;
  93         Evas_Coord dry;
  94         Evas_Coord drw;
  95         Evas_Coord drh;
  96
  97         Ecore_Timer *phone_lock_timer;
  98         Ecore_Timer *slide_timer;
  99         Ecore_Timer *emgc_up_timer;
 100         Ecore_Timer *info_timer;
 101
 102         int heynoti_fd;
 103
 104         Elm_Theme *theme;
 105
 106         phone_lock_view_password_type_t lock_type;
 107         phone_lock_view_type_t view_type;
 108         phone_lock_window_type_t window_type;
 109         phone_lock_view_info_align_type_t align_type;
 110
 111         char *contents;
 112         phone_lock_view_cbfunc func;
 113         void *user_data;
 114 };
 115
 116 #define PHONE_LOCK_VIEW_PHONE_LOCK_MAX_LENGTH 16
 117 #define PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK_MAX_LENGTH 4
 118
 119 #define EMGC_EV_R                       0.073
 120 #define EMGC_H                          55
 121 #define WIN_H                           800
 122 #define EMGC_DOWN_Y                     717
 123 #define EMGC_UP_Y                       357
 124 #define EMGC_REL_DOWN_Y(win_h)  ((win_h * EMGC_DOWN_Y) / WIN_H)
 125 #define EMGC_REL_UP_Y(win_h)    ((win_h * EMGC_UP_Y) / WIN_H)
 126
 127 static Evas_Object *arrow_icon[6] = { 0 };
 128
 129 static Evas_Coord start_pos = 0;
 130
 131 static void _phone_lock_view_enable_phone_lock(void *data);
 132 static void _phone_lock_view_disable_phone_lock(void *data);
 133 static void _phone_lock_view_enable_simple_phone_lock(void *data);
 134 static void _phone_lock_view_disable_simple_phone_lock(void *data);
 135 static Eina_Bool _phone_lock_view_update_phone_lock_cb(void *data);
 136 static void _phone_lock_view_update_phone_lock(void *data);
 137 static void _phone_lock_view_check_vconf_value(void *data);
 138 static void _phone_lock_view_check_vconf_value_cb(keynode_t * key, void *data);
 139 static void _phone_lock_view_notify_pm_state_cb(keynode_t * key, void *data);
 140 static void _phone_lock_view_create_customed_entry(void *data);
 141 static void _phone_lock_view_destroy_customed_entry(void *data);
 142 static inline const char *_phone_lock_view_entry_get(Evas_Object * obj);
 143 static void _phone_lock_view_set_str(char **s, const char *str);
 144 static void _phone_lock_view_clear_entry_contents(void *data);
 145 static Evas_Object *_phone_lock_view_editfield_create(Evas_Object * parent,
 146                                                       void *data);
 147 static Evas_Object *_phone_lock_view_editfield_entry_get(Evas_Object * parent);
 148
 149 static inline const char *_phone_lock_view_entry_get(Evas_Object * obj)
 150 {
 151         const char *s = NULL;
 152
 153         if (obj)
 154                 s = elm_entry_entry_get(_phone_lock_view_editfield_entry_get
 155                                         (obj));
 156
 157         return s;
 158 }
 159
 160 static void _phone_lock_view_set_str(char **s, const char *str)
 161 {
 162         if (s == NULL)
 163                 return;
 164
 165         if (*s)
 166                 free(*s);
 167
 168         if (str && str[0] != '\0')
 169                 *s = strdup(str);
 170         else
 171                 *s = NULL;
 172 }
 173
 174 static void _phone_lock_view_popup_timeout_cb(void *data, Evas_Object * obj,
 175                 void *event_info)
 176 {
 177         PHONE_LOCK_DBG("timeout cb : %d", (int)event_info);
 178         phone_lock_view_data_t *phone_lock_view_data =
 179                         (phone_lock_view_data_t *) data;
 180
 181         if (phone_lock_view_data == NULL) {
 182                 return;
 183         }
 184
 185         _phone_lock_view_clear_entry_contents(data);
 186         phone_lock_view_show_imf_context_input_panel(data);
 187         if (((int) event_info != 5) && (obj != NULL)) {
 188                 evas_object_del(obj);
 189                 obj = NULL;
 190         }
 191 }
 192
 193 static void _phone_lock_view_block_clicked_cb(void *data, Evas_Object * obj,
 194                 void *event_info)
 195 {
 196         PHONE_LOCK_DBG("block clicked cb : %d", (int)event_info);
 197         phone_lock_view_data_t *phone_lock_view_data =
 198                         (phone_lock_view_data_t *) data;
 199
 200         if (phone_lock_view_data == NULL) {
 201                 return;
 202         }
 203
 204         _phone_lock_view_clear_entry_contents(data);
 205         phone_lock_view_show_imf_context_input_panel(data);
 206         if (obj) {
 207                 evas_object_del(obj);
 208                 obj = NULL;
 209         }
 210 }
 211
 212 static Evas_Object *_phone_lock_view_create_layout(Evas_Object * parent,
 213                                                    const char *file,
 214                                                    const char *group)
 215 {
 216         Evas_Object *layout;
 217         Eina_Bool ret = EINA_FALSE;
 218
 219         layout = elm_layout_add(parent);
 220
 221         if (file != NULL && group != NULL) {
 222                 ret = elm_layout_file_set(layout, file, group);
 223                 if (ret != EINA_TRUE) {
 224                         PHONE_LOCK_ERR("Fail elm_layout_file_set");
 225                         evas_object_del(layout);
 226                         return NULL;
 227                 }
 228         } else {
 229                 elm_layout_theme_set(layout, "layout", "application",
 230                                      "default");
 231                 elm_win_resize_object_add(parent, layout);
 232                 elm_win_indicator_mode_set(parent, ELM_WIN_INDICATOR_SHOW);
 233         }
 234
 235         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 236                                          EVAS_HINT_EXPAND);
 237
 238         evas_object_show(layout);
 239
 240         return layout;
 241 }
 242
 243 static void _phone_lock_view_create_bg_image(Evas_Object * parent)
 244 {
 245         char *file = NULL;
 246         Evas_Object *image = NULL;
 247         Eina_Bool ret = EINA_FALSE;
 248
 249         if (!parent) {
 250                 return;
 251         }
 252         PHONE_LOCK_DBG("");
 253
 254         if ((file = vconf_get_str(VCONFKEY_IDLE_LOCK_BGSET)) != NULL) {
 255
 256         } else if ((file = vconf_get_str(VCONFKEY_BGSET)) != NULL) {
 257
 258         }
 259         PHONE_LOCK_DBG("file = %s", file);
 260
 261         image = elm_image_add(parent);
 262         if (file) {
 263                 ret = elm_image_file_set(image, file, NULL);
 264                 if (ret == EINA_FALSE) {
 265                         elm_image_file_set(image,
 266                                            PHONE_LOCK_VIEW_DEFAULT_BG_PATH,
 267                                            NULL);
 268                 }
 269                 free(file);
 270                 file = NULL;
 271         }
 272
 273         elm_object_part_content_set(parent, "swallow.bg", image);
 274         evas_object_show(image);
 275 }
 276
 277 static Eina_Bool _phone_lock_view_set_info_time(void *data)
 278 {
 279         Evas_Object *time_label = NULL;
 280         Evas_Object *date_label = NULL;
 281         Evas_Object *info = NULL;
 282         Ecore_Timer *info_timer = NULL;
 283         struct tm st;
 284         time_t tt;
 285         char buf[512] = { 0, };
 286         char bf1[32] = { 0, };
 287         char bf2[32] = { 0, };
 288         int r;
 289         int hour;
 290         phone_lock_view_data_t *phone_lock_view_data = NULL;
 291         enum appcore_time_format timeformat;
 292
 293         phone_lock_view_data = (phone_lock_view_data_t *) data;
 294
 295         if (!phone_lock_view_data) {
 296                 return 0;
 297         }
 298         PHONE_LOCK_DBG("");
 299
 300         info = phone_lock_view_data->info;
 301         info_timer = phone_lock_view_data->info_timer;
 302
 303         if (!info) {
 304                 return 0;
 305         }
 306
 307         tt = time(NULL);
 308         localtime_r(&tt, &st);
 309
 310         if (info_timer != NULL) {
 311                 ecore_timer_del(info_timer);
 312                 info_timer = NULL;
 313         }
 314
 315         info_timer =
 316             ecore_timer_add(60 - st.tm_sec, _phone_lock_view_set_info_time,
 317                             phone_lock_view_data);
 318         phone_lock_view_data->info_timer = info_timer;
 319
 320         r = appcore_get_timeformat(&timeformat);
 321         if (r == 0 && timeformat == APPCORE_TIME_FORMAT_24) {
 322                 strftime(bf1, sizeof(bf1), "%H:%M", &st);
 323                 switch (phone_lock_view_data->align_type) {
 324                 case PHONE_LOCK_VIEW_ALIGN_LEFT:
 325                         snprintf(buf, sizeof(buf), "%s%s%s",
 326                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=left>",
 327                                  bf1, "</>");
 328                         break;
 329                 case PHONE_LOCK_VIEW_ALIGN_CENTER:
 330                         snprintf(buf, sizeof(buf), "%s%s%s",
 331                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=center>",
 332                                  bf1, "</>");
 333                         break;
 334                 case PHONE_LOCK_VIEW_ALIGN_RIGHT:
 335                         snprintf(buf, sizeof(buf), "%s%s%s",
 336                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=right>",
 337                                  bf1, "</>");
 338                         break;
 339                 }
 340                 PHONE_LOCK_DBG("buf = %s", buf);
 341         } else {
 342                 strftime(bf1, sizeof(bf1), "%l", &st);
 343                 hour = atoi(bf1);
 344                 strftime(bf1, sizeof(bf1), ":%M", &st);
 345
 346                 if (st.tm_hour >= 0 && st.tm_hour < 12)
 347                         snprintf(bf2, sizeof(bf2), "%s", "AM");
 348                 else
 349                         snprintf(bf2, sizeof(bf2), "%s", "PM");
 350
 351                 switch (phone_lock_view_data->align_type) {
 352                 case PHONE_LOCK_VIEW_ALIGN_LEFT:
 353                         snprintf(buf, sizeof(buf), "%s%d%s%s %s%s%s",
 354                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=left>",
 355                                  hour, bf1,
 356                                  "</>",
 357                                  "<font_size=36 font=SLP:style=Bold style=shadow shadow_color=#000000bf color=#ffffffff align=left>",
 358                                  bf2, "</>");
 359                         break;
 360                 case PHONE_LOCK_VIEW_ALIGN_CENTER:
 361                         snprintf(buf, sizeof(buf), "%s%d%s%s %s%s%s",
 362                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=center>",
 363                                  hour, bf1,
 364                                  "</>",
 365                                  "<font_size=36 font=SLP:style=Bold style=shadow shadow_color=#000000bf color=#ffffffff align=center>",
 366                                  bf2, "</>");
 367                         break;
 368                 case PHONE_LOCK_VIEW_ALIGN_RIGHT:
 369                         snprintf(buf, sizeof(buf), "%s%d%s%s %s%s%s",
 370                                  "<font_size=150 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=right>",
 371                                  hour, bf1,
 372                                  "</>",
 373                                  "<font_size=36 font=SLP:style=Bold style=shadow shadow_color=#000000bf color=#ffffffff align=right>",
 374                                  bf2, "</>");
 375                         break;
 376                 }
 377                 PHONE_LOCK_DBG("buf = %s", buf);
 378         }
 379
 380         time_label = elm_label_add(info);
 381         elm_object_text_set(time_label, buf);
 382         elm_object_part_content_set(info, "label.time", time_label);
 383
 384         UErrorCode status = U_ZERO_ERROR;
 385         UDateTimePatternGenerator *generator;
 386         UDateFormat *formatter;
 387         UChar skeleton[40] = { 0 }
 388         , pattern[40] = {
 389         0}
 390         , formatted[40] = {
 391         0};
 392         int32_t patternCapacity, formattedCapacity;
 393         int32_t skeletonLength, patternLength, formattedLength;
 394         UDate date;
 395         const char *locale;
 396         const char customSkeleton[] = UDAT_MONTH_WEEKDAY_DAY;
 397
 398         /* set UDate  from time_t */
 399         date = (UDate) tt *1000;
 400
 401         /* get default locale  */
 402         uloc_setDefault(__secure_getenv("LC_TIME"), &status);   /* for thread saftey  */
 403         locale = uloc_getDefault();
 404
 405         /* open datetime pattern generator */
 406         generator = udatpg_open(locale, &status);
 407         if (generator == NULL)
 408                 return 0;
 409
 410         /* calculate pattern string capacity */
 411         patternCapacity = (int32_t) (sizeof(pattern) / sizeof((pattern)[0]));
 412
 413         /* ascii to unicode for input skeleton */
 414         u_uastrcpy(skeleton, customSkeleton);
 415
 416         /* get skeleton length */
 417         skeletonLength = strlen(customSkeleton);
 418
 419         /* get best pattern using skeleton */
 420         patternLength =
 421             udatpg_getBestPattern(generator, skeleton, skeletonLength, pattern,
 422                                   patternCapacity, &status);
 423
 424         /* open datetime formatter using best pattern */
 425         formatter =
 426             udat_open(UDAT_IGNORE, UDAT_DEFAULT, locale, NULL, -1, pattern,
 427                       patternLength, &status);
 428         if (formatter == NULL) {
 429                 udatpg_close(generator);
 430         }
 431
 432         /* calculate formatted string capacity */
 433         formattedCapacity =
 434             (int32_t) (sizeof(formatted) / sizeof((formatted)[0]));
 435
 436         /* formatting date using formatter by best pattern */
 437         formattedLength =
 438             udat_format(formatter, date, formatted, formattedCapacity, NULL,
 439                         &status);
 440
 441         /* unicode to ascii to display */
 442         u_austrcpy(bf1, formatted);
 443         PHONE_LOCK_DBG("formatted string=%s", bf1);
 444
 445         /* close datetime pattern generator */
 446         udatpg_close(generator);
 447
 448         /* close datetime formatter */
 449         udat_close(formatter);
 450
 451         switch (phone_lock_view_data->align_type) {
 452         case PHONE_LOCK_VIEW_ALIGN_LEFT:
 453                 snprintf(buf, sizeof(buf), "%s%s%s",
 454                          "<font_size=45 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=left>",
 455                          bf1, "</>");
 456                 break;
 457         case PHONE_LOCK_VIEW_ALIGN_CENTER:
 458                 snprintf(buf, sizeof(buf), "%s%s%s",
 459                          "<font_size=45 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=center>",
 460                          bf1, "</>");
 461                 break;
 462         case PHONE_LOCK_VIEW_ALIGN_RIGHT:
 463                 snprintf(buf, sizeof(buf), "%s%s%s",
 464                          "<font_size=45 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff align=right>",
 465                          bf1, "</>");
 466                 break;
 467         }
 468
 469         PHONE_LOCK_DBG("buf = %s", buf);
 470
 471         date_label = elm_label_add(info);
 472         elm_object_text_set(date_label, buf);
 473         elm_object_part_content_set(info, "label.date", date_label);
 474
 475         evas_object_show(time_label);
 476         evas_object_show(date_label);
 477
 478         return 0;
 479 }
 480
 481 static void
 482 _phone_lock_view_set_info(phone_lock_view_data_t * phone_lock_view_data)
 483 {
 484         Evas_Object *bg = NULL;
 485         Evas_Object *info = NULL;
 486
 487         if (!phone_lock_view_data) {
 488                 return;
 489         }
 490         PHONE_LOCK_DBG("");
 491
 492         bg = phone_lock_view_data->background;
 493
 494         if (!bg) {
 495                 return;
 496         }
 497         _phone_lock_view_set_info_time(phone_lock_view_data);
 498
 499         info = phone_lock_view_data->info;
 500
 501         if (!info) {
 502                 return;
 503         }
 504         elm_object_part_content_set(bg, "swallow.info.2", info);
 505 }
 506
 507 static void _phone_lock_view_wakeup_cb(void *data)
 508 {
 509         phone_lock_view_data_t *phone_lock_view_data = NULL;
 510         PHONE_LOCK_DBG("%s  %d", __FUNCTION__, __LINE__);
 511
 512         phone_lock_view_data = (phone_lock_view_data_t *) data;
 513
 514         if (phone_lock_view_data)
 515                 _phone_lock_view_set_info_time(phone_lock_view_data);
 516 }
 517
 518 static int _phone_lock_view_init_heynoti(phone_lock_view_data_t * phone_lock_view_data)
 519 {
 520         int fd = 0, ret = -1;
 521         PHONE_LOCK_DBG("%s  %d", __FUNCTION__, __LINE__);
 522
 523         fd = heynoti_init();
 524         if (fd == -1) {
 525                 PHONE_LOCK_ERR("Noti init error\n");
 526                 return -1;
 527         }
 528
 529         ret = heynoti_subscribe(fd, SYSTEM_RESUME, _phone_lock_view_wakeup_cb, phone_lock_view_data);
 530         if (ret) {
 531                 PHONE_LOCK_ERR
 532                     ("[Error] heynoti_subscribe : system_wakeup\n");
 533                 return -1;
 534         }
 535
 536         ret = heynoti_attach_handler(fd);
 537         if (ret) {
 538                 PHONE_LOCK_ERR
 539                     ("[Error] heynoti_attach_handler failed.\n");
 540                 return -1;
 541         }
 542
 543         phone_lock_view_data->heynoti_fd = fd;
 544
 545         return EXIT_SUCCESS;
 546 }
 547
 548 static void _phone_lock_fini_heynoti(phone_lock_view_data_t * phone_lock_view_data)
 549 {
 550         PHONE_LOCK_DBG("%s  %d", __FUNCTION__, __LINE__);
 551         heynoti_unsubscribe(phone_lock_view_data->heynoti_fd, SYSTEM_RESUME, _phone_lock_view_wakeup_cb);
 552
 553         heynoti_close(phone_lock_view_data->heynoti_fd);
 554
 555         phone_lock_view_data->heynoti_fd = 0;
 556 }
 557
 558 static void
 559 _phone_lock_view_create_info(phone_lock_view_data_t * phone_lock_view_data)
 560 {
 561         Evas_Object *bg = NULL;
 562         Evas_Object *info = NULL;
 563
 564         if (!phone_lock_view_data) {
 565                 return;
 566         }
 567         PHONE_LOCK_DBG("");
 568
 569         bg = phone_lock_view_data->background;
 570
 571         if (!bg) {
 572                 return;
 573         }
 574
 575         info = _phone_lock_view_create_layout(bg, EDJ_PHONE_LOCK_VIEW,
 576                                               "phlock.view.info");
 577         if (info == NULL) {
 578                 PHONE_LOCK_ERR("[Error] Cannot add layout: info\n");
 579                 return;
 580         }
 581
 582         if (_phone_lock_view_init_heynoti(phone_lock_view_data) < 0) {
 583                 PHONE_LOCK_ERR("heynoti ERR..!!");
 584         }
 585
 586         phone_lock_view_data->info = info;
 587         _phone_lock_view_set_info(phone_lock_view_data);
 588
 589         evas_object_show(phone_lock_view_data->info);
 590 }
 591
 592 static void _phone_lock_view_set_color_start(int count, int r, int g, int b,
 593                                              int a)
 594 {
 595         int i = 0;
 596         for (i = count; i < 6; i++) {
 597                 evas_object_color_set(arrow_icon[i], r, g, b, a);
 598         }
 599 }
 600
 601 static void _phone_lock_view_set_color_index(int index, int r, int g, int b,
 602                                              int a)
 603 {
 604
 605         evas_object_color_set(arrow_icon[index], r, g, b, a);
 606 }
 607
 608 static void _phone_lock_view_arrow_down_cb(void *data, Evas * evas,
 609                                            Evas_Object * obj, void *event_info)
 610 {
 611         phone_lock_view_data_t *phone_lock_view_data =
 612             (phone_lock_view_data_t *) data;
 613
 614         if (phone_lock_view_data == NULL) {
 615                 return;
 616         }
 617         PHONE_LOCK_DBG("_phone_lock_view_arrow_down_cb");
 618         Evas_Event_Mouse_Down *ev = event_info;
 619         start_pos = ev->canvas.x;
 620         PHONE_LOCK_DBG("_phone_lock_view_arrow_down_cb start_pos = %d",
 621                        start_pos);
 622 }
 623
 624 static void _phone_lock_view_arrow_up_cb(void *data, Evas * evas,
 625                                          Evas_Object * obj, void *event_info)
 626 {
 627         phone_lock_view_data_t *phone_lock_view_data =
 628             (phone_lock_view_data_t *) data;
 629
 630         if (phone_lock_view_data == NULL) {
 631                 return;
 632         }
 633         PHONE_LOCK_DBG("_phone_lock_view_arrow_up_cb");
 634
 635         Evas_Event_Mouse_Down *ev = event_info;
 636         if ((ev->canvas.x - start_pos) > 440 * (phone_lock_view_data->scale)) {
 637                 phone_lock_view_hide_imf_context_input_panel
 638                     (phone_lock_view_data);
 639                 if (phone_lock_view_data->func) {
 640                         phone_lock_view_data->is_callug_launched = EINA_TRUE;
 641                         phone_lock_view_data->func(1, NULL,
 642                                                    phone_lock_view_data->user_data);
 643                 }
 644         } else {
 645         }
 646         _phone_lock_view_set_color_start(0, 255, 255, 255, 255);
 647 }
 648
 649 static void _phone_lock_view_arrow_move_cb(void *data, Evas * evas,
 650                                            Evas_Object * obj, void *event_info)
 651 {
 652         phone_lock_view_data_t *phone_lock_view_data =
 653             (phone_lock_view_data_t *) data;
 654
 655         if (phone_lock_view_data == NULL) {
 656                 return;
 657         }
 658         PHONE_LOCK_DBG("_phone_lock_view_arrow_move_cb");
 659         PHONE_LOCK_DBG
 660             ("_phone_lock_view_arrow_move_cb: phone_lock_view_data->scale = %f",
 661              phone_lock_view_data->scale);
 662         Evas_Event_Mouse_Down *ev = event_info;
 663         if (ev->canvas.x <= 96 * (phone_lock_view_data->scale)) {
 664                 _phone_lock_view_set_color_start(0, 255, 255, 255, 255);
 665         } else if (ev->canvas.x > 96 * (phone_lock_view_data->scale)
 666                    && ev->canvas.x <= 184 * (phone_lock_view_data->scale)) {
 667                 _phone_lock_view_set_color_start(0, 255, 255, 255, 255);
 668                 _phone_lock_view_set_color_index(0, 0, 191, 255, 255);
 669         } else if (ev->canvas.x > 184 * (phone_lock_view_data->scale)
 670                    && ev->canvas.x <= 272 * (phone_lock_view_data->scale)) {
 671                 _phone_lock_view_set_color_start(1, 255, 255, 255, 255);
 672                 _phone_lock_view_set_color_index(1, 0, 191, 255, 255);
 673         } else if (ev->canvas.x > 272 * (phone_lock_view_data->scale)
 674                    && ev->canvas.x <= 360 * (phone_lock_view_data->scale)) {
 675                 _phone_lock_view_set_color_start(2, 255, 255, 255, 255);
 676                 _phone_lock_view_set_color_index(2, 0, 191, 255, 255);
 677         } else if (ev->canvas.x > 360 * (phone_lock_view_data->scale)
 678                    && ev->canvas.x <= 448 * (phone_lock_view_data->scale)) {
 679                 _phone_lock_view_set_color_start(3, 255, 255, 255, 255);
 680                 _phone_lock_view_set_color_index(3, 0, 191, 255, 255);
 681         } else if (ev->canvas.x > 448 * (phone_lock_view_data->scale)
 682                    && ev->canvas.x <= 536 * (phone_lock_view_data->scale)) {
 683                 _phone_lock_view_set_color_start(4, 255, 255, 255, 255);
 684                 _phone_lock_view_set_color_index(4, 0, 191, 255, 255);
 685         } else if (ev->canvas.x > 536 * (phone_lock_view_data->scale)) {
 686                 _phone_lock_view_set_color_start(5, 255, 255, 255, 255);
 687                 _phone_lock_view_set_color_index(5, 0, 191, 255, 255);
 688         }
 689 }
 690
 691 static void
 692 _phone_lock_view_create_emergency_event(phone_lock_view_data_t *
 693                                         phone_lock_view_data)
 694 {
 695         Evas_Object *event = NULL;
 696         Evas_Object *bg = NULL;
 697         Evas_Object *emergency_icon = NULL;
 698         Evas_Object *emergency_text = NULL;
 699         char buf[512] = { 0, };
 700         int i = 0;
 701         /* create dragable */
 702         event =
 703             _phone_lock_view_create_layout(phone_lock_view_data->layout_main,
 704                                            EDJ_PHONE_LOCK_VIEW,
 705                                            "phlock.view.event");
 706         if (event == NULL) {
 707                 PHONE_LOCK_ERR("[Error] Cannot add layout: event\n");
 708                 return;
 709         }
 710
 711         phone_lock_view_data->event = event;
 712         bg = phone_lock_view_data->background;
 713
 714         for (i = 0; i < 6; i++) {
 715                 if (arrow_icon[i]) {
 716                         evas_object_del(arrow_icon[i]);
 717                         arrow_icon[i] = NULL;
 718                 }
 719                 arrow_icon[i] = elm_image_add(bg);
 720                 elm_image_file_set(arrow_icon[i],
 721                                    PHONE_LOCK_VIEW_ARROW_DEFAULT_IMG, NULL);
 722                 snprintf(buf, sizeof(buf), "%s%d", "arrow_icon_", i);
 723                 elm_object_part_content_set(event, buf, arrow_icon[i]);
 724                 evas_object_show(arrow_icon[i]);
 725         }
 726
 727         emergency_icon = elm_image_add(bg);
 728         elm_image_file_set(emergency_icon, PHONE_LOCK_VIEW_EMERGENCY_CALL_IMG,
 729                            NULL);
 730         elm_object_part_content_set(event, "emergency_icon", emergency_icon);
 731         evas_object_show(emergency_icon);
 732
 733         emergency_text = elm_label_add(bg);
 734         snprintf(buf, sizeof(buf), "%s%s%s",
 735                  "<font_size=25 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffffff>",
 736                  phone_lock_get_string(IDS_IDLE_BODY_EMERGENCY_CALL), "</>");
 737         PHONE_LOCK_DBG("buf = %s", buf);
 738         elm_object_text_set(emergency_text, buf);
 739         elm_object_part_content_set(event, "emergency_text", emergency_text);
 740
 741         evas_object_show(emergency_text);
 742
 743         evas_object_event_callback_add(event, EVAS_CALLBACK_MOUSE_MOVE,
 744                                        _phone_lock_view_arrow_move_cb,
 745                                        phone_lock_view_data);
 746         evas_object_event_callback_add(event, EVAS_CALLBACK_MOUSE_DOWN,
 747                                        _phone_lock_view_arrow_down_cb,
 748                                        phone_lock_view_data);
 749         evas_object_event_callback_add(event, EVAS_CALLBACK_MOUSE_UP,
 750                                        _phone_lock_view_arrow_up_cb,
 751                                        phone_lock_view_data);
 752         evas_object_show(event);
 753         elm_object_part_content_set(bg, "swallow.event.down", event);
 754 }
 755
 756 static void
 757 _phone_lock_view_entry_changed_cb(void *data, Evas_Object * obj,
 758                                   void *event_info)
 759 {
 760         PHONE_LOCK_DBG("");
 761 }
 762
 763 static void
 764 _phone_lock_view_entry_activated_cb(void *data, Evas_Object * obj,
 765                                     void *event_info)
 766 {
 767         PHONE_LOCK_DBG("enter key clicked!!\n");
 768         phone_lock_view_data_t *phone_lock_view_data =
 769             (phone_lock_view_data_t *) data;
 770
 771         if (phone_lock_view_data == NULL) {
 772                 return;
 773         }
 774
 775         phone_lock_view_data->is_customedentry_clicked = EINA_TRUE;
 776 }
 777
 778 static void
 779 _phone_lock_view_input_panel_event_cb(void *data,
 780                                       Ecore_IMF_Context * imf_context,
 781                                       int value)
 782 {
 783         PHONE_LOCK_DBG("");
 784         phone_lock_view_data_t *phone_lock_view_data =
 785             (phone_lock_view_data_t *) data;
 786
 787         if (phone_lock_view_data == NULL) {
 788                 return;
 789         }
 790
 791         Evas_Coord x;
 792         Evas_Coord y;
 793         Evas_Coord w;
 794         Evas_Coord h;
 795         double dx;
 796         double dy;
 797         switch (value) {
 798         case ECORE_IMF_INPUT_PANEL_STATE_SHOW:
 799                 /*  Move up emergency object */
 800                 evas_object_geometry_get(phone_lock_view_data->event, &x, &y,
 801                                          &w, &h);
 802                 PHONE_LOCK_DBG("y = %d", y);
 803                 edje_object_signal_emit(_EDJ(phone_lock_view_data->background),
 804                                         "bg.up", "swallow.event.bg");
 805                 edje_object_signal_emit(_EDJ(phone_lock_view_data->background),
 806                                         "bg.up", "swallow.event");
 807                 elm_object_part_content_unset(phone_lock_view_data->background,
 808                                               "swallow.event.down");
 809                 elm_object_part_content_set(phone_lock_view_data->background,
 810                                             "swallow.event.up",
 811                                             phone_lock_view_data->event);
 812
 813                 break;
 814         case ECORE_IMF_INPUT_PANEL_STATE_HIDE:
 815                 /*  Move down Emergency call event if current focus is not emergency call */
 816                 edje_object_part_drag_value_get(_EDJ
 817                                                 (phone_lock_view_data->event),
 818                                                 "sw.slider", &dx, &dy);
 819                 evas_object_geometry_get(phone_lock_view_data->event, &x, &y,
 820                                          &w, &h);
 821                 PHONE_LOCK_DBG("dx= %f", dx);
 822                 PHONE_LOCK_DBG("y = %d", y);
 823
 824                 edje_object_signal_emit(_EDJ(phone_lock_view_data->background),
 825                                         "bg.down", "swallow.event.bg");
 826                 edje_object_signal_emit(_EDJ(phone_lock_view_data->background),
 827                                         "bg.down", "swallow.event");
 828                 elm_object_part_content_unset(phone_lock_view_data->background,
 829                                               "swallow.event.up");
 830                 elm_object_part_content_set(phone_lock_view_data->background,
 831                                             "swallow.event.down",
 832                                             phone_lock_view_data->event);
 833
 834                 break;
 835         default:
 836                 break;
 837         }
 838 }
 839
 840 static void _phone_lock_view_button_up_cb(void *data, Evas_Object * obj,
 841                                           const char *emission,
 842                                           const char *source)
 843 {
 844         PHONE_LOCK_DBG("");
 845
 846         phone_lock_view_data_t *phone_lock_view_data =
 847             (phone_lock_view_data_t *) data;
 848
 849         if (NULL == phone_lock_view_data) {
 850                 return;
 851         }
 852
 853         edje_object_signal_emit(elm_layout_edje_get
 854                                 (phone_lock_view_data->input), "release",
 855                                 "button");
 856
 857         phone_lock_view_hide_imf_context_input_panel(phone_lock_view_data);
 858
 859         if (phone_lock_view_data->func) {
 860                 _phone_lock_view_set_str(&phone_lock_view_data->contents,
 861                                          elm_entry_entry_get
 862                                          (phone_lock_view_data->input_entry));
 863                 PHONE_LOCK_DBG("%s, phone_lock_view_data->contents : %s",
 864                                __FUNCTION__, phone_lock_view_data->contents);
 865                 phone_lock_view_data->func(2, phone_lock_view_data->contents,
 866                                            phone_lock_view_data->user_data);
 867         }
 868 }
 869
 870 static void _phone_lock_view_button_down_cb(void *data, Evas_Object * obj,
 871                                             const char *emission,
 872                                             const char *source)
 873 {
 874         PHONE_LOCK_DBG("");
 875
 876         phone_lock_view_data_t *phone_lock_view_data =
 877             (phone_lock_view_data_t *) data;
 878
 879         if (NULL == phone_lock_view_data) {
 880                 return;
 881         }
 882
 883         edje_object_signal_emit(elm_layout_edje_get
 884                                 (phone_lock_view_data->input), "press",
 885                                 "button");
 886 }
 887
 888 static void _phone_lock_view_create_customed_entry(void *data)
 889 {
 890         Evas_Object *entry = NULL;
 891         Evas_Object *input = NULL;
 892         Evas_Object *background = NULL;
 893
 894         static Elm_Entry_Filter_Limit_Size limit_filter_data_alpha;
 895
 896         phone_lock_view_data_t *phone_lock_view_data =
 897             (phone_lock_view_data_t *) data;
 898
 899         if (phone_lock_view_data == NULL) {
 900                 return;
 901         }
 902
 903         background = phone_lock_view_data->background;
 904         input = phone_lock_view_data->input;
 905
 906         entry = elm_entry_add(background);
 907
 908         Elm_Theme *th = elm_theme_new();
 909         elm_theme_ref_set(th, NULL);
 910         elm_theme_extension_add(th, EDJ_PHONE_LOCK_VIEW_ENTRY);
 911
 912         elm_object_theme_set(entry, th);
 913         elm_object_style_set(entry, "phone_lock_alpha_style");
 914
 915         limit_filter_data_alpha.max_char_count =
 916             PHONE_LOCK_VIEW_PHONE_LOCK_MAX_LENGTH;
 917         limit_filter_data_alpha.max_byte_count = 0;
 918         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
 919                                        &limit_filter_data_alpha);
 920
 921         elm_entry_single_line_set(entry, EINA_TRUE);
 922         elm_entry_password_set(entry, EINA_TRUE);
 923         elm_entry_entry_set(entry, "");
 924         elm_entry_cursor_end_set(entry);
 925         elm_object_part_content_set(input, "swallow.text", entry);
 926
 927         Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(entry);
 928         ecore_imf_context_input_panel_event_callback_add(imf_context,
 929                                                          ECORE_IMF_INPUT_PANEL_STATE_EVENT,
 930                                                          _phone_lock_view_input_panel_event_cb,
 931                                                          phone_lock_view_data);
 932         ecore_imf_context_input_panel_language_set(imf_context,
 933                                                    ECORE_IMF_INPUT_PANEL_LANG_ALPHABET);
 934
 935         phone_lock_view_data->input_entry = entry;
 936         phone_lock_view_data->theme = th;
 937         phone_lock_view_data->is_customedentry_clicked = EINA_FALSE;
 938 }
 939
 940 static void _phone_lock_view_destroy_customed_entry(void *data)
 941 {
 942         Evas_Object *entry = NULL;
 943         Evas_Object *input = NULL;
 944         Elm_Theme *th = NULL;
 945
 946         phone_lock_view_data_t *phone_lock_view_data =
 947             (phone_lock_view_data_t *) data;
 948
 949         if (phone_lock_view_data == NULL) {
 950                 return;
 951         }
 952
 953         input = phone_lock_view_data->input;
 954         entry = phone_lock_view_data->input_entry;
 955         th = phone_lock_view_data->theme;
 956
 957         elm_object_part_content_unset(input, "swallow.text");
 958
 959         if (entry) {
 960                 evas_object_del(entry);
 961                 entry = NULL;
 962         }
 963         if (th) {
 964                 elm_theme_free(th);
 965                 th = NULL;
 966         }
 967 }
 968
 969 static void _phone_lock_view_enable_phone_lock(void *data)
 970 {
 971         Evas_Object *label = NULL;
 972         Evas_Object *entry = NULL;
 973         Evas_Object *input = NULL;
 974         Evas_Object *background = NULL;
 975         char buf[256] = { 0, };
 976
 977         phone_lock_view_data_t *phone_lock_view_data =
 978             (phone_lock_view_data_t *) data;
 979
 980         if (phone_lock_view_data == NULL) {
 981                 return;
 982         }
 983
 984         label = phone_lock_view_data->title_label;
 985         entry = phone_lock_view_data->input_entry;
 986         input = phone_lock_view_data->input;
 987         background = phone_lock_view_data->background;
 988
 989         snprintf(buf, sizeof(buf), "%s%s%s",
 990                  "<font_size=62 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffff align=center>",
 991                  phone_lock_get_string(IDS_COM_BODY_ENTER_PASSWORD), "</>");
 992         elm_object_text_set(label, buf);
 993         elm_object_part_content_set(background, "swallow.input", input);
 994         evas_object_smart_callback_add(entry, "changed",
 995                                        _phone_lock_view_entry_changed_cb, NULL);
 996         evas_object_smart_callback_add(entry, "focused",
 997                                        _phone_lock_view_entry_activated_cb,
 998                                        phone_lock_view_data);
 999         evas_object_show(input);
1000 }
1001
1002 static void _phone_lock_view_disable_phone_lock(void *data)
1003 {
1004         Evas_Object *label = NULL;
1005         Evas_Object *entry = NULL;
1006         Evas_Object *input = NULL;
1007         Evas_Object *background = NULL;
1008         char buf[256] = { 0, };
1009         char buf_str[50] = { 0, };
1010         PHONE_LOCK_DBG("%s", __FUNCTION__);
1011
1012         phone_lock_view_data_t *phone_lock_view_data =
1013             (phone_lock_view_data_t *) data;
1014
1015         if (phone_lock_view_data == NULL) {
1016                 return;
1017         }
1018
1019         label = phone_lock_view_data->title_label;
1020         entry = phone_lock_view_data->input_entry;
1021         input = phone_lock_view_data->input;
1022         background = phone_lock_view_data->background;
1023         snprintf(buf_str, sizeof(buf_str),
1024                  phone_lock_get_string(IDS_IDLE_BODY_TRY_LATER),
1025                  phone_lock_view_data->block_seconds);
1026         snprintf(buf, sizeof(buf), "%s%s%s",
1027                  "<font_size=62 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffff align=center>",
1028                  buf_str, "</>");
1029         elm_object_text_set(label, buf);
1030
1031         elm_object_part_content_unset(background, "swallow.input");
1032         evas_object_hide(input);
1033
1034         evas_object_smart_callback_del(entry, "changed",
1035                                        _phone_lock_view_entry_changed_cb);
1036         evas_object_smart_callback_del(entry, "focused",
1037                                        _phone_lock_view_entry_activated_cb);
1038
1039         ecore_timer_thaw(phone_lock_view_data->phone_lock_timer);
1040 }
1041
1042 static void _phone_lock_view_enable_simple_phone_lock(void *data)
1043 {
1044         Evas_Object *label = NULL;
1045         Evas_Object *label1 = NULL;
1046         Evas_Object *label2 = NULL;
1047         Evas_Object *label3 = NULL;
1048         Evas_Object *label4 = NULL;
1049         Evas_Object *input = NULL;
1050         Evas_Object *background = NULL;
1051         char buf[256] = { 0, };
1052
1053         phone_lock_view_data_t *phone_lock_view_data =
1054             (phone_lock_view_data_t *) data;
1055
1056         if (phone_lock_view_data == NULL) {
1057                 return;
1058         }
1059
1060         label = phone_lock_view_data->title_label;
1061         label1 = phone_lock_view_data->sp_label1;
1062         label2 = phone_lock_view_data->sp_label2;
1063         label3 = phone_lock_view_data->sp_label3;
1064         label4 = phone_lock_view_data->sp_label4;
1065         input = phone_lock_view_data->input;
1066         background = phone_lock_view_data->background;
1067
1068         snprintf(buf, sizeof(buf), "%s%s%s",
1069                  "<font_size=62 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffff align=center>",
1070                  phone_lock_get_string(IDS_COM_BODY_ENTER_PASSWORD), "</>");
1071         elm_object_text_set(label, buf);
1072         elm_object_text_set(label1, "");
1073         elm_object_text_set(label2, "");
1074         elm_object_text_set(label3, "");
1075         elm_object_text_set(label4, "");
1076         elm_object_part_content_set(background, "swallow.input", input);
1077         evas_object_show(input);
1078 }
1079
1080 static void _phone_lock_view_disable_simple_phone_lock(void *data)
1081 {
1082         Evas_Object *label = NULL;
1083         Evas_Object *input = NULL;
1084         Evas_Object *background = NULL;
1085         char buf[256] = { 0, };
1086         char buf_str[50] = { 0, };
1087         PHONE_LOCK_DBG("%s", __FUNCTION__);
1088
1089         phone_lock_view_data_t *phone_lock_view_data =
1090             (phone_lock_view_data_t *) data;
1091
1092         if (phone_lock_view_data == NULL) {
1093                 return;
1094         }
1095
1096         label = phone_lock_view_data->title_label;
1097         input = phone_lock_view_data->input;
1098         background = phone_lock_view_data->background;
1099         snprintf(buf_str, sizeof(buf_str),
1100                  phone_lock_get_string(IDS_IDLE_BODY_TRY_LATER),
1101                  phone_lock_view_data->block_seconds);
1102         snprintf(buf, sizeof(buf), "%s%s%s",
1103                  "<font_size=62 font=SLP:style=Light style=shadow shadow_color=#000000bf color=#ffffff align=center>",
1104                  buf_str, "</>");
1105         elm_object_text_set(label, buf);
1106
1107         elm_object_part_content_unset(background, "swallow.input");
1108         evas_object_hide(input);
1109         ecore_timer_thaw(phone_lock_view_data->phone_lock_timer);
1110 }
1111
1112 static Eina_Bool _phone_lock_view_update_phone_lock_cb(void *data)
1113 {
1114         _phone_lock_view_update_phone_lock(data);
1115         return EINA_TRUE;
1116 }
1117
1118 static void _phone_lock_view_update_phone_lock(void *data)
1119 {
1120         int value = -1;
1121         int ret = 0;
1122
1123         phone_lock_view_data_t *phone_lock_view_data =
1124             (phone_lock_view_data_t *) data;
1125
1126         if (phone_lock_view_data == NULL) {
1127                 return;
1128         }
1129         PHONE_LOCK_DBG("%s", __FUNCTION__);
1130
1131         ret =
1132             vconf_get_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1133                           &value);
1134
1135         if (ret != 0) {
1136                 return;
1137         }
1138
1139         if (value == 0) {
1140                 char timestamp_str
1141                     [PHONE_LOCK_VIEW_PHONE_LOCK_TIMESTAMP_STR_LENGTH + 1] =
1142                     { 0, };
1143                 char *temp = NULL;
1144                 int length = 0;
1145                 int temp_length = 0;
1146                 temp = vconf_get_str(VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR);
1147                 temp_length = strlen(temp);
1148                 length =
1149                     (temp_length <=
1150                      PHONE_LOCK_VIEW_PHONE_LOCK_TIMESTAMP_STR_LENGTH) ?
1151                     temp_length :
1152                     PHONE_LOCK_VIEW_PHONE_LOCK_TIMESTAMP_STR_LENGTH;
1153                 strncpy(timestamp_str, temp, length);
1154                 timestamp_str[length] = '\0';
1155                 if ((strcmp(timestamp_str, "") != 0)
1156                     || (strlen(timestamp_str) != 0)) {
1157                         time_t cur_time = time(NULL);
1158                         time_t last_lock_time;
1159                         sscanf(timestamp_str, "%ld", &last_lock_time);
1160
1161                         if ((cur_time - last_lock_time) <
1162                             PHONE_LOCK_VIEW_PHONE_LOCK_BLOCK_SECONDS) {
1163                                 phone_lock_view_data->block_seconds =
1164                                     PHONE_LOCK_VIEW_PHONE_LOCK_BLOCK_SECONDS -
1165                                     (cur_time - last_lock_time);
1166                                 PHONE_LOCK_DBG
1167                                     ("phone_lock_view_data->block_seconds = %d",
1168                                      phone_lock_view_data->block_seconds);
1169                                 phone_lock_view_data->view_disabled = 1;
1170                                 switch (phone_lock_view_data->lock_type) {
1171                                 case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1172                                         _phone_lock_view_disable_phone_lock
1173                                             (phone_lock_view_data);
1174                                         break;
1175                                 case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1176                                         _phone_lock_view_disable_simple_phone_lock(phone_lock_view_data);
1177                                         break;
1178                                 default:
1179                                         break;
1180                                 }
1181                         } else {
1182                                 phone_lock_view_data->view_disabled = 0;
1183                                 vconf_set_int
1184                                     (VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1185                                      PHONE_LOCK_VIEW_PHONE_LOCK_ATTEMPTS_MAX);
1186
1187                                 PHONE_LOCK_DBG
1188                                     ("phone_lock_view_data->view_disabled = %d",
1189                                      phone_lock_view_data->view_disabled);
1190                                 switch (phone_lock_view_data->lock_type) {
1191                                 case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1192                                         _phone_lock_view_destroy_customed_entry
1193                                             (phone_lock_view_data);
1194                                         _phone_lock_view_create_customed_entry
1195                                             (phone_lock_view_data);
1196                                         _phone_lock_view_enable_phone_lock
1197                                             (phone_lock_view_data);
1198                                         break;
1199                                 case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1200                                         _phone_lock_view_enable_simple_phone_lock(phone_lock_view_data);
1201                                         if (phone_lock_view_data->is_callug_launched == EINA_FALSE) {
1202                                                 phone_lock_view_show_imf_context_input_panel
1203                                                     (phone_lock_view_data);
1204                                         }
1205                                         break;
1206                                 default:
1207                                         break;
1208                                 }
1209                         }
1210                 }
1211         }
1212 }
1213
1214 static void _phone_lock_view_check_vconf_value(void *data)
1215 {
1216         int phone_lock_value = -1;
1217         phone_lock_view_data_t *phone_lock_view_data =
1218             (phone_lock_view_data_t *) data;
1219
1220         if (phone_lock_view_data == NULL) {
1221                 return;
1222         }
1223         PHONE_LOCK_DBG("%s", __FUNCTION__);
1224
1225         vconf_get_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1226                       &phone_lock_value);
1227
1228         if (phone_lock_value == 0) {
1229                 if (phone_lock_view_data->phone_lock_timer) {
1230                         return;
1231                 }
1232                 phone_lock_view_data->phone_lock_timer =
1233                     ecore_timer_add(1, (Ecore_Task_Cb)
1234                                     _phone_lock_view_update_phone_lock_cb,
1235                                     phone_lock_view_data);
1236         } else {
1237                 if (phone_lock_view_data->phone_lock_timer) {
1238                         ecore_timer_del(phone_lock_view_data->phone_lock_timer);
1239                         phone_lock_view_data->phone_lock_timer = NULL;
1240                 }
1241                 phone_lock_view_data->view_disabled = 0;
1242                 switch (phone_lock_view_data->lock_type) {
1243                 case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1244                         _phone_lock_view_enable_phone_lock
1245                             (phone_lock_view_data);
1246                         break;
1247                 case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1248                         _phone_lock_view_enable_simple_phone_lock
1249                             (phone_lock_view_data);
1250                         break;
1251                 default:
1252                         break;
1253                 }
1254         }
1255 }
1256
1257 static void _phone_lock_view_check_vconf_value_cb(keynode_t * key, void *data)
1258 {
1259         _phone_lock_view_check_vconf_value(data);
1260 }
1261
1262 static void _phone_lock_view_clear_entry_contents(void *data)
1263 {
1264         phone_lock_view_data_t *phone_lock_view_data =
1265             (phone_lock_view_data_t *) data;
1266
1267         if (phone_lock_view_data == NULL) {
1268                 return;
1269         }
1270
1271         PHONE_LOCK_DBG("%s", __FUNCTION__);
1272
1273         switch (phone_lock_view_data->lock_type) {
1274         case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1275                 PHONE_LOCK_DBG("Clear the complex pw's entry.");
1276                 if (phone_lock_view_data->input_entry) {
1277                         elm_entry_entry_set
1278                             (phone_lock_view_data->input_entry, "");
1279                 }
1280                 break;
1281         case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1282                 PHONE_LOCK_DBG("Clear the simple pw's entry.");
1283                 if (phone_lock_view_data->editfield_layout) {
1284                         elm_entry_entry_set(_phone_lock_view_editfield_entry_get
1285                                             (phone_lock_view_data->editfield_layout),
1286                                             "");
1287                 }
1288                 phone_lock_view_data->is_simple_pw_checking = EINA_FALSE;
1289                 break;
1290         }
1291 }
1292
1293 /* reset: clear entry and hide keypad */
1294 static void _phone_lock_view_notify_pm_state_cb(keynode_t * key, void *data)
1295 {
1296         phone_lock_view_data_t *phone_lock_view_data =
1297             (phone_lock_view_data_t *) data;
1298         int val = -1;
1299
1300         if (phone_lock_view_data == NULL) {
1301                 return;
1302         }
1303
1304         PHONE_LOCK_DBG("%s", __FUNCTION__);
1305
1306         if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) {
1307                 PHONE_LOCK_ERR("Cannot get VCONFKEY_PM_STATE");
1308                 return;
1309         }
1310
1311         if (val == VCONFKEY_PM_STATE_LCDOFF) {
1312                 _phone_lock_view_clear_entry_contents(phone_lock_view_data);
1313                 phone_lock_view_hide_imf_context_input_panel
1314                     (phone_lock_view_data);
1315         }
1316 }
1317
1318 void
1319 _phone_lock_view_create_alpha_view_complex_lock(phone_lock_view_data_t *
1320                                                 phone_lock_view_data)
1321 {
1322         Evas_Object *background = NULL;
1323         Evas_Object *label = NULL;
1324         Evas_Object *title_label = NULL;
1325         Evas_Object *input = NULL;
1326         Evas_Object *entry = NULL;
1327         char buf[256] = { 0, };
1328         static Elm_Entry_Filter_Limit_Size limit_filter_data_alpha;
1329
1330         background =
1331             _phone_lock_view_create_layout(phone_lock_view_data->layout_main,
1332                                            EDJ_PHONE_LOCK_VIEW,
1333                                            "phlock.view.main");
1334
1335         evas_object_resize(background, phone_lock_view_data->win_w,
1336                            phone_lock_view_data->win_h);
1337         evas_object_show(background);
1338
1339         _phone_lock_view_create_bg_image(background);
1340
1341         title_label = elm_label_add(background);
1342         elm_object_part_content_set(background, "swallow.title", title_label);
1343
1344         evas_object_show(title_label);
1345         input =
1346             _phone_lock_view_create_layout(background, EDJ_PHONE_LOCK_VIEW,
1347                                            "phlock.view.input.complex");
1348
1349         entry = elm_entry_add(background);
1350
1351         Elm_Theme *th = elm_theme_new();
1352         elm_theme_ref_set(th, NULL);
1353         elm_theme_extension_add(th, EDJ_PHONE_LOCK_VIEW_ENTRY);
1354
1355         elm_object_theme_set(entry, th);
1356         elm_object_style_set(entry, "phone_lock_alpha_style");
1357
1358         limit_filter_data_alpha.max_char_count =
1359             PHONE_LOCK_VIEW_PHONE_LOCK_MAX_LENGTH;
1360         limit_filter_data_alpha.max_byte_count = 0;
1361         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
1362                                        &limit_filter_data_alpha);
1363
1364         elm_entry_single_line_set(entry, EINA_TRUE);
1365         elm_entry_password_set(entry, EINA_TRUE);
1366         elm_entry_entry_set(entry, "");
1367         elm_entry_cursor_end_set(entry);
1368         elm_object_part_content_set(input, "swallow.text", entry);
1369
1370         Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(entry);
1371         ecore_imf_context_input_panel_event_callback_add(imf_context,
1372                                                          ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1373                                                          _phone_lock_view_input_panel_event_cb,
1374                                                          phone_lock_view_data);
1375         ecore_imf_context_input_panel_language_set(imf_context,
1376                                                    ECORE_IMF_INPUT_PANEL_LANG_ALPHABET);
1377
1378         label = elm_label_add(background);
1379
1380         snprintf(buf, sizeof(buf), "%s%s%s",
1381                  "<font_size=34 font=SLP:style=Roman color=#ffffff align=center>",
1382                  phone_lock_get_string(IDS_COM_SK_OK), "</>");
1383         elm_object_text_set(label, buf);
1384         elm_object_part_content_set(input, "swallow.button", label);
1385
1386         evas_object_show(label);
1387
1388         edje_object_signal_callback_add(_EDJ(input), "mouse,up,1", "button",
1389                                         _phone_lock_view_button_up_cb,
1390                                         phone_lock_view_data);
1391         edje_object_signal_callback_add(_EDJ(input), "mouse,down,1", "button",
1392                                         _phone_lock_view_button_down_cb,
1393                                         phone_lock_view_data);
1394
1395         phone_lock_view_data->background = background;
1396         phone_lock_view_data->input_label = label;
1397         phone_lock_view_data->title_label = title_label;
1398         phone_lock_view_data->input_entry = entry;
1399         phone_lock_view_data->input = input;
1400         phone_lock_view_data->theme = th;
1401
1402         _phone_lock_view_create_emergency_event(phone_lock_view_data);
1403         _phone_lock_view_create_info(phone_lock_view_data);
1404         _phone_lock_view_update_phone_lock(phone_lock_view_data);
1405         vconf_notify_key_changed
1406             (VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1407              _phone_lock_view_check_vconf_value_cb, phone_lock_view_data);
1408         vconf_notify_key_changed(VCONFKEY_PM_STATE,
1409                                  _phone_lock_view_notify_pm_state_cb,
1410                                  phone_lock_view_data);
1411         _phone_lock_view_check_vconf_value(phone_lock_view_data);
1412 }
1413
1414 static void _phone_lock_view_set_entry_bg_color(void *data)
1415 {
1416         phone_lock_view_data_t *phone_lock_view_data =
1417             (phone_lock_view_data_t *) data;
1418         char *s = NULL;
1419         int length = 0;
1420         Evas_Object *editfield_layout = NULL;
1421
1422         if (!phone_lock_view_data) {
1423                 return;
1424         }
1425         editfield_layout = phone_lock_view_data->editfield_layout;
1426         if (editfield_layout) {
1427                 s = (char *)
1428                     elm_entry_entry_get(_phone_lock_view_editfield_entry_get
1429                                         (editfield_layout));
1430         }
1431
1432         PHONE_LOCK_DBG("%s s = %s", __FUNCTION__, s);
1433         length = strlen(s);
1434         switch (length) {
1435         case 0:
1436                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1437                                         "sp1_bg_set_default", "sp1_bg");
1438                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1439                                         "sp2_bg_set_default", "sp2_bg");
1440                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1441                                         "sp3_bg_set_default", "sp3_bg");
1442                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1443                                         "sp4_bg_set_default", "sp4_bg");
1444                 break;
1445         case 1:
1446                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1447                                         "sp1_bg_set_input", "sp1_bg");
1448                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1449                                         "sp2_bg_set_default", "sp2_bg");
1450                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1451                                         "sp3_bg_set_default", "sp3_bg");
1452                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1453                                         "sp4_bg_set_default", "sp4_bg");
1454                 break;
1455         case 2:
1456                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1457                                         "sp1_bg_set_input", "sp1_bg");
1458                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1459                                         "sp2_bg_set_input", "sp2_bg");
1460                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1461                                         "sp3_bg_set_default", "sp3_bg");
1462                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1463                                         "sp4_bg_set_default", "sp4_bg");
1464                 break;
1465         case 3:
1466                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1467                                         "sp1_bg_set_input", "sp1_bg");
1468                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1469                                         "sp2_bg_set_input", "sp2_bg");
1470                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1471                                         "sp3_bg_set_input", "sp3_bg");
1472                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1473                                         "sp4_bg_set_default", "sp4_bg");
1474                 break;
1475         case 4:
1476                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1477                                         "sp1_bg_set_input", "sp1_bg");
1478                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1479                                         "sp2_bg_set_input", "sp2_bg");
1480                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1481                                         "sp3_bg_set_input", "sp3_bg");
1482                 edje_object_signal_emit(_EDJ(phone_lock_view_data->input),
1483                                         "sp4_bg_set_input", "sp4_bg");
1484                 break;
1485         }
1486 }
1487
1488 static void _phone_lock_view_simple_entry_changed_cb(void *data,
1489                                                      Evas_Object * obj,
1490                                                      void *event_info)
1491 {
1492         phone_lock_view_data_t *phone_lock_view_data =
1493             (phone_lock_view_data_t *) data;
1494         char *s = NULL;
1495         int length = 0;
1496         Evas_Object *editfield_layout = NULL;
1497         Evas_Object *label1 = NULL;
1498         Evas_Object *label2 = NULL;
1499         Evas_Object *label3 = NULL;
1500         Evas_Object *label4 = NULL;
1501         char buf[255] = { 0 };
1502
1503         if (!phone_lock_view_data) {
1504                 return;
1505         }
1506
1507         if (phone_lock_view_data->is_simple_pw_checking == EINA_TRUE) {
1508                 return;
1509         }
1510         editfield_layout = phone_lock_view_data->editfield_layout;
1511         if (obj) {
1512                 s = (char *)
1513                     elm_entry_entry_get(_phone_lock_view_editfield_entry_get
1514                                         (editfield_layout));
1515         }
1516
1517         if (elm_object_focus_get(editfield_layout)) {
1518                 if (elm_entry_is_empty
1519                     (_phone_lock_view_editfield_entry_get(editfield_layout))) {
1520                         elm_object_signal_emit(editfield_layout,
1521                                                "elm,state,eraser,hide", "elm");
1522                 } else {
1523                         elm_object_signal_emit(editfield_layout,
1524                                                "elm,state,eraser,show", "elm");
1525                 }
1526         }
1527
1528         PHONE_LOCK_DBG("%s s = %s", __FUNCTION__, s);
1529         length = strlen(s);
1530         label1 = phone_lock_view_data->sp_label1;
1531         label2 = phone_lock_view_data->sp_label2;
1532         label3 = phone_lock_view_data->sp_label3;
1533         label4 = phone_lock_view_data->sp_label4;
1534         snprintf(buf, sizeof(buf), "%s%s%s",
1535                  "<font_size=70 font=SLP:style=Roman color=#ffffff align=center>",
1536                  "*", "</>");
1537         switch (length) {
1538         case 0:
1539                 elm_object_text_set(label1, "");
1540                 elm_object_text_set(label2, "");
1541                 elm_object_text_set(label3, "");
1542                 elm_object_text_set(label4, "");
1543                 break;
1544         case 1:
1545                 elm_object_text_set(label1, buf);
1546                 elm_object_text_set(label2, "");
1547                 elm_object_text_set(label3, "");
1548                 elm_object_text_set(label4, "");
1549                 break;
1550         case 2:
1551                 elm_object_text_set(label1, buf);
1552                 elm_object_text_set(label2, buf);
1553                 elm_object_text_set(label3, "");
1554                 elm_object_text_set(label4, "");
1555                 break;
1556         case 3:
1557                 elm_object_text_set(label1, buf);
1558                 elm_object_text_set(label2, buf);
1559                 elm_object_text_set(label3, buf);
1560                 elm_object_text_set(label4, "");
1561                 break;
1562         case 4:
1563                 elm_object_text_set(label1, buf);
1564                 elm_object_text_set(label2, buf);
1565                 elm_object_text_set(label3, buf);
1566                 elm_object_text_set(label4, buf);
1567                 break;
1568         }
1569         _phone_lock_view_set_entry_bg_color(phone_lock_view_data);
1570
1571         if (length != 4) {
1572                 PHONE_LOCK_DBG("%s  %d", __FUNCTION__, __LINE__);
1573                 return;
1574         }
1575         PHONE_LOCK_DBG("%s  %d length = %d", __FUNCTION__, __LINE__, length);
1576         phone_lock_view_hide_imf_context_input_panel(phone_lock_view_data);
1577         _phone_lock_view_set_str(&phone_lock_view_data->contents,
1578                                  _phone_lock_view_entry_get(editfield_layout));
1579
1580         if (phone_lock_view_data->func) {
1581                 phone_lock_view_data->func(2, phone_lock_view_data->contents,
1582                                            phone_lock_view_data->user_data);
1583                 phone_lock_view_data->is_simple_pw_checking = EINA_TRUE;
1584                 PHONE_LOCK_DBG("%s  %d phone_lock_view_data->contents = %s",
1585                                __FUNCTION__, __LINE__,
1586                                phone_lock_view_data->contents);
1587         }
1588 }
1589
1590 static void _phone_lock_view_label_signal_process(void *data, Evas_Object * o,
1591                                                   const char *emission,
1592                                                   const char *source)
1593 {
1594         phone_lock_view_data_t *phone_lock_view_data =
1595             (phone_lock_view_data_t *) data;
1596         PHONE_LOCK_DBG("emission = %s", emission);
1597         if (!phone_lock_view_data) {
1598                 return;
1599         }
1600
1601         if ((strcmp("sp1_entry_clicked", emission) == 0)
1602             || (strcmp("sp2_entry_clicked", emission) == 0)
1603             || (strcmp("sp3_entry_clicked", emission) == 0)
1604             || (strcmp("sp4_entry_clicked", emission) == 0)) {
1605                 phone_lock_view_show_imf_context_input_panel
1606                     (phone_lock_view_data);
1607         }
1608         _phone_lock_view_set_entry_bg_color(phone_lock_view_data);
1609 }
1610
1611 static void _phone_lock_view_focused_cb(void *data, Evas_Object * obj,
1612                                         void *event_info)
1613 {
1614         PHONE_LOCK_DBG("_focused_cb\n");
1615         if (!elm_entry_is_empty(obj)) {
1616                 elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
1617         }
1618         elm_object_signal_emit(data, "elm,state,guidetext,hide", "elm");
1619 }
1620
1621 static void _phone_lock_view_unfocused_cb(void *data, Evas_Object * obj,
1622                                           void *event_info)
1623 {
1624         PHONE_LOCK_DBG("_unfocused_cb\n");
1625         if (elm_entry_is_empty(obj)) {
1626                 elm_object_signal_emit(data, "elm,state,guidetext,show", "elm");
1627         }
1628         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
1629 }
1630
1631 static void _phone_lock_view_eraser_clicked_cb(void *data, Evas_Object * obj,
1632                                                const char *emission,
1633                                                const char *source)
1634 {
1635         PHONE_LOCK_DBG("_eraser_clicked_cb\n");
1636         elm_entry_entry_set(data, "");
1637 }
1638
1639 static Evas_Object *_phone_lock_view_editfield_create(Evas_Object * parent,
1640                                                       void *data)
1641 {
1642         Evas_Object *layout = NULL;
1643         Evas_Object *entry = NULL;
1644         phone_lock_view_data_t *phone_lock_view_data =
1645             (phone_lock_view_data_t *) data;
1646         static Elm_Entry_Filter_Limit_Size limit_filter_data;
1647
1648         limit_filter_data.max_char_count = PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK_MAX_LENGTH;        /* hard code for demo */
1649         limit_filter_data.max_byte_count = 0;
1650         PHONE_LOCK_DBG("_openlock_setting_pw_editfield_create\n");
1651
1652         layout = elm_layout_add(parent);
1653         elm_layout_theme_set(layout, "layout", "editfield", "default");
1654
1655         entry = elm_entry_add(parent);
1656         elm_entry_scrollable_set(entry, EINA_TRUE);
1657         elm_entry_single_line_set(entry, EINA_TRUE);
1658         elm_entry_password_set(entry, EINA_TRUE);
1659         elm_object_focus_set(entry, EINA_TRUE);
1660         elm_entry_input_panel_layout_set(entry,
1661                                          ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
1662         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
1663                                        &limit_filter_data);
1664         evas_object_show(layout);
1665         if (entry) {
1666                 elm_object_focus_set(entry, EINA_TRUE);
1667                 phone_lock_view_data->is_customedentry_clicked = EINA_TRUE;
1668         }
1669         evas_object_move(entry, -100, -100);    /* can't be seen */
1670         evas_object_hide(entry);
1671
1672         evas_object_smart_callback_add(entry, "changed",
1673                                        _phone_lock_view_simple_entry_changed_cb,
1674                                        phone_lock_view_data);
1675         evas_object_smart_callback_add(entry, "focused",
1676                                        _phone_lock_view_focused_cb, layout);
1677         evas_object_smart_callback_add(entry, "unfocused",
1678                                        _phone_lock_view_unfocused_cb, layout);
1679
1680         elm_object_part_content_set(layout, "elm.swallow.content", entry);
1681         elm_object_part_text_set(layout, "elm.guidetext", "");
1682         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm",
1683                                        _phone_lock_view_eraser_clicked_cb,
1684                                        entry);
1685         return layout;
1686 }
1687
1688 static Evas_Object *_phone_lock_view_editfield_entry_get(Evas_Object * parent)
1689 {
1690         Evas_Object *entry = NULL;
1691
1692         entry = elm_object_part_content_get(parent, "elm.swallow.content");
1693
1694         return entry;
1695 }
1696
1697 void
1698 _phone_lock_view_create_alpha_view_simple_lock(phone_lock_view_data_t *
1699                                                phone_lock_view_data)
1700 {
1701         Evas_Object *background = NULL;
1702         Evas_Object *title_label = NULL;
1703         Evas_Object *label1 = NULL;
1704         Evas_Object *label2 = NULL;
1705         Evas_Object *label3 = NULL;
1706         Evas_Object *label4 = NULL;
1707         Evas_Object *layout = NULL;
1708         Evas_Object *input = NULL;
1709
1710         background =
1711             _phone_lock_view_create_layout(phone_lock_view_data->layout_main,
1712                                            EDJ_PHONE_LOCK_VIEW,
1713                                            "phlock.view.main.simple");
1714
1715         evas_object_resize(background, phone_lock_view_data->win_w,
1716                            phone_lock_view_data->win_h);
1717         evas_object_show(background);
1718
1719         _phone_lock_view_create_bg_image(background);
1720
1721         title_label = elm_label_add(background);
1722         elm_object_text_set(title_label, "");
1723         elm_object_part_content_set(background, "swallow.title", title_label);
1724
1725         evas_object_show(title_label);
1726
1727         input =
1728             _phone_lock_view_create_layout(background, EDJ_PHONE_LOCK_VIEW,
1729                                            "phlock.view.input.simple");
1730
1731         layout =
1732             _phone_lock_view_editfield_create(background, phone_lock_view_data);
1733
1734         Ecore_IMF_Context *imf_context =
1735             elm_entry_imf_context_get(_phone_lock_view_editfield_entry_get
1736                                       (layout));
1737         ecore_imf_context_input_panel_event_callback_add(imf_context,
1738                                                          ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1739                                                          _phone_lock_view_input_panel_event_cb,
1740                                                          phone_lock_view_data);
1741         ecore_imf_context_input_panel_language_set(imf_context,
1742                                                    ECORE_IMF_INPUT_PANEL_LANG_ALPHABET);
1743
1744         label1 = elm_label_add(background);
1745         elm_object_text_set(label1, "");
1746         elm_object_part_content_set(input, "sp1_entry", label1);
1747         evas_object_show(label1);
1748
1749         label2 = elm_label_add(background);
1750         elm_object_text_set(label2, "");
1751         elm_object_part_content_set(input, "sp2_entry", label2);
1752         evas_object_show(label2);
1753
1754         label3 = elm_label_add(background);
1755         elm_object_text_set(label3, "");
1756         elm_object_part_content_set(input, "sp3_entry", label3);
1757         evas_object_show(label3);
1758
1759         label4 = elm_label_add(background);
1760         elm_object_text_set(label4, "");
1761         elm_object_part_content_set(input, "sp4_entry", label4);
1762         evas_object_show(label4);
1763
1764         edje_object_signal_callback_add(_EDJ(input), "sp1_entry_clicked", "*",
1765                                         _phone_lock_view_label_signal_process,
1766                                         phone_lock_view_data);
1767         edje_object_signal_callback_add(_EDJ(input), "sp2_entry_clicked", "*",
1768                                         _phone_lock_view_label_signal_process,
1769                                         phone_lock_view_data);
1770         edje_object_signal_callback_add(_EDJ(input), "sp3_entry_clicked", "*",
1771                                         _phone_lock_view_label_signal_process,
1772                                         phone_lock_view_data);
1773         edje_object_signal_callback_add(_EDJ(input), "sp4_entry_clicked", "*",
1774                                         _phone_lock_view_label_signal_process,
1775                                         phone_lock_view_data);
1776
1777         phone_lock_view_data->background = background;
1778         phone_lock_view_data->title_label = title_label;
1779         phone_lock_view_data->editfield_layout = layout;
1780         phone_lock_view_data->sp_label1 = label1;
1781         phone_lock_view_data->sp_label2 = label2;
1782         phone_lock_view_data->sp_label3 = label3;
1783         phone_lock_view_data->sp_label4 = label4;
1784         phone_lock_view_data->input = input;
1785
1786         _phone_lock_view_create_emergency_event(phone_lock_view_data);
1787         _phone_lock_view_create_info(phone_lock_view_data);
1788         _phone_lock_view_update_phone_lock(phone_lock_view_data);
1789         vconf_notify_key_changed
1790             (VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1791              _phone_lock_view_check_vconf_value_cb, phone_lock_view_data);
1792         vconf_notify_key_changed(VCONFKEY_PM_STATE,
1793                                  _phone_lock_view_notify_pm_state_cb,
1794                                  phone_lock_view_data);
1795         _phone_lock_view_check_vconf_value(phone_lock_view_data);
1796 }
1797
1798 phone_lock_view_data_t *phone_lock_view_create(phone_lock_view_type_t view_type,
1799                                                phone_lock_window_type_t
1800                                                window_type,
1801                                                Evas_Object * win_main,
1802                                                phone_lock_view_cbfunc func,
1803                                                void *user_data)
1804 {
1805         PHONE_LOCK_DBG("%s,  win : %p", __FUNCTION__, win_main);
1806
1807         phone_lock_view_data_t *phone_lock_view_data;
1808         phone_lock_view_data =
1809             (phone_lock_view_data_t *) malloc(sizeof(phone_lock_view_data_t));
1810         if (!phone_lock_view_data)
1811                 return NULL;
1812
1813         memset(phone_lock_view_data, 0, sizeof(phone_lock_view_data_t));
1814
1815         ecore_x_window_size_get(ecore_x_window_root_first_get(),
1816                                 &phone_lock_view_data->win_w,
1817                                 &phone_lock_view_data->win_h);
1818
1819         phone_lock_view_data->view_type = view_type;
1820         phone_lock_view_data->window_type = window_type;
1821         phone_lock_view_data->win_main = win_main;
1822         phone_lock_view_data->func = func;
1823         phone_lock_view_data->user_data = user_data;
1824         phone_lock_view_data->scale =
1825             (double)(phone_lock_view_data->win_w) /
1826             (double)PHONE_LOCK_VIEW_MAIN_W;
1827
1828         phone_lock_view_data->layout_main =
1829             _phone_lock_view_create_layout(phone_lock_view_data->win_main, NULL,
1830                                            NULL);
1831
1832         if (window_type == PHONE_LOCK_WINDOW_TYPE_ALPHA) {
1833                 int simple_password_on = 0;
1834                 evas_object_color_set(phone_lock_view_data->layout_main, 255, 255, 255, 0.7);   /* for alpha window */
1835                 vconf_get_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL,
1836                                &simple_password_on);
1837                 if (simple_password_on == 1) {
1838                         phone_lock_view_data->lock_type =
1839                             PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK;
1840                 } else {
1841                         phone_lock_view_data->lock_type =
1842                             PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK;
1843                 }
1844                 PHONE_LOCK_DBG("phone_lock_view_data->lock_type = %d\n",
1845                                phone_lock_view_data->lock_type);
1846
1847                 if (view_type >= PHONE_LOCK_VIEW_TYPE_PHONE_LOCK
1848                     && view_type < PHONE_LOCK_VIEW_TYPE_PHONE_MAX) {
1849                         switch (phone_lock_view_data->lock_type) {
1850                         case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1851                                 _phone_lock_view_create_alpha_view_complex_lock
1852                                     (phone_lock_view_data);
1853                                 break;
1854                         case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1855                                 _phone_lock_view_create_alpha_view_simple_lock
1856                                     (phone_lock_view_data);
1857                                 break;
1858                         default:
1859                                 break;
1860                         }
1861                 } else {
1862                         PHONE_LOCK_DBG("Error. Invalide view type\n");
1863                         free(phone_lock_view_data);
1864                         return NULL;
1865                 }
1866         }
1867         return phone_lock_view_data;
1868 }
1869
1870 void phone_lock_view_destroy(phone_lock_view_data_t * phone_lock_view_data)
1871 {
1872         vconf_ignore_key_changed(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
1873                                  _phone_lock_view_check_vconf_value_cb);
1874         vconf_ignore_key_changed(VCONFKEY_PM_STATE,
1875                                  _phone_lock_view_notify_pm_state_cb);
1876         PHONE_LOCK_DBG("%s", __FUNCTION__);
1877         if (phone_lock_view_data) {
1878                 _phone_lock_fini_heynoti(phone_lock_view_data);
1879                 ecore_imf_context_input_panel_event_callback_del
1880                     (elm_entry_imf_context_get
1881                      (_phone_lock_view_editfield_entry_get
1882                       (phone_lock_view_data->editfield_layout)),
1883                      ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1884                      _phone_lock_view_input_panel_event_cb);
1885                 ecore_imf_context_input_panel_event_callback_del
1886                     (elm_entry_imf_context_get
1887                      (phone_lock_view_data->input_entry),
1888                      ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1889                      _phone_lock_view_input_panel_event_cb);
1890                 if (phone_lock_view_data->emgc_up_timer) {
1891                         ecore_timer_del(phone_lock_view_data->emgc_up_timer);
1892                         phone_lock_view_data->emgc_up_timer = NULL;
1893                 }
1894                 if (phone_lock_view_data->slide_timer) {
1895                         ecore_timer_del(phone_lock_view_data->slide_timer);
1896                         phone_lock_view_data->slide_timer = NULL;
1897                 }
1898
1899                 if (phone_lock_view_data->phone_lock_timer) {
1900                         ecore_timer_del(phone_lock_view_data->phone_lock_timer);
1901                         phone_lock_view_data->phone_lock_timer = NULL;
1902                 }
1903                 if (phone_lock_view_data->info_timer) {
1904                         ecore_timer_del(phone_lock_view_data->info_timer);
1905                         phone_lock_view_data->info_timer = NULL;
1906                 }
1907
1908                 if (phone_lock_view_data->contents) {
1909                         free(phone_lock_view_data->contents);
1910                         phone_lock_view_data->contents = NULL;
1911                 }
1912                 if (phone_lock_view_data->sp_label1) {
1913                         evas_object_del(phone_lock_view_data->sp_label1);
1914                         phone_lock_view_data->sp_label1 = NULL;
1915                 }
1916                 if (phone_lock_view_data->sp_label2) {
1917                         evas_object_del(phone_lock_view_data->sp_label2);
1918                         phone_lock_view_data->sp_label2 = NULL;
1919                 }
1920                 if (phone_lock_view_data->sp_label3) {
1921                         evas_object_del(phone_lock_view_data->sp_label3);
1922                         phone_lock_view_data->sp_label3 = NULL;
1923                 }
1924                 if (phone_lock_view_data->sp_label4) {
1925                         evas_object_del(phone_lock_view_data->sp_label4);
1926                         phone_lock_view_data->sp_label4 = NULL;
1927                 }
1928                 if (phone_lock_view_data->editfield_layout) {
1929                         evas_object_del(phone_lock_view_data->editfield_layout);
1930                         phone_lock_view_data->editfield_layout = NULL;
1931                 }
1932                 if (phone_lock_view_data->info) {
1933                         evas_object_del(phone_lock_view_data->info);
1934                         phone_lock_view_data->info = NULL;
1935                 }
1936
1937                 if (phone_lock_view_data->theme) {
1938                         elm_theme_extension_del(phone_lock_view_data->theme,
1939                                                 EDJ_PHONE_LOCK_VIEW_ENTRY);
1940                         elm_theme_free(phone_lock_view_data->theme);
1941                 }
1942                 if (phone_lock_view_data->layout_main) {
1943                         evas_object_del(phone_lock_view_data->layout_main);
1944                         phone_lock_view_data->layout_main = NULL;
1945                 }
1946         }
1947
1948         free(phone_lock_view_data);
1949         phone_lock_view_data = NULL;
1950 }
1951
1952 Evas_Object *phone_lock_view_get_layoutmain(phone_lock_view_data_t *
1953                                             phone_lock_view_data)
1954 {
1955         return phone_lock_view_data->layout_main;
1956 }
1957
1958 phone_lock_view_type_t phone_lock_view_get_type(phone_lock_view_data_t *
1959                                                 phone_lock_view_data)
1960 {
1961         return phone_lock_view_data->view_type;
1962 }
1963
1964 phone_lock_window_type_t
1965 phone_lock_window_get_type(phone_lock_view_data_t * phone_lock_view_data)
1966 {
1967         return phone_lock_view_data->window_type;
1968 }
1969
1970 void phone_lock_view_hide_imf_context_input_panel(void *data)
1971 {
1972         PHONE_LOCK_DBG("");
1973         phone_lock_view_data_t *phone_lock_view_data =
1974             (phone_lock_view_data_t *) data;
1975         Ecore_IMF_Context *imf_context = NULL;
1976
1977         if (NULL == phone_lock_view_data) {
1978                 return;
1979         }
1980
1981         switch (phone_lock_view_data->lock_type) {
1982         case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
1983                 imf_context =
1984                     elm_entry_imf_context_get
1985                     (phone_lock_view_data->input_entry);
1986                 if (imf_context) {
1987                         ecore_imf_context_input_panel_hide(imf_context);
1988                 }
1989                 break;
1990         case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
1991                 evas_object_hide(phone_lock_view_data->editfield_layout);
1992                 elm_object_focus_set(_phone_lock_view_editfield_entry_get
1993                                      (phone_lock_view_data->editfield_layout),
1994                                      EINA_FALSE);
1995                 imf_context =
1996                     elm_entry_imf_context_get
1997                     (_phone_lock_view_editfield_entry_get
1998                      (phone_lock_view_data->editfield_layout));
1999                 if (imf_context) {
2000                         ecore_imf_context_input_panel_hide(imf_context);
2001                 }
2002                 break;
2003         default:
2004                 break;
2005         }
2006 }
2007
2008 void phone_lock_view_show_imf_context_input_panel(void *data)
2009 {
2010         PHONE_LOCK_DBG("");
2011         phone_lock_view_data_t *phone_lock_view_data =
2012             (phone_lock_view_data_t *) data;
2013         Ecore_IMF_Context *imf_context = NULL;
2014
2015         if (NULL == phone_lock_view_data) {
2016                 return;
2017         }
2018
2019         PHONE_LOCK_DBG
2020             ("phone_lock_view_data->is_callug_launched = %d,phone_lock_view_data->is_customedentry_clicked = %d",
2021              phone_lock_view_data->is_callug_launched,
2022              phone_lock_view_data->is_customedentry_clicked);
2023         PHONE_LOCK_DBG
2024             ("phone_lock_view_data->view_disabled = %d,phone_lock_view_data->is_customedentry_clicked = %d",
2025              phone_lock_view_data->view_disabled,
2026              phone_lock_view_data->is_customedentry_clicked);
2027         PHONE_LOCK_DBG
2028             ("phone_lock_view_data->view_disabled = %d,phone_lock_view_data->is_customedentry_clicked = %d",
2029              phone_lock_view_data->view_disabled,
2030              phone_lock_view_data->is_customedentry_clicked);
2031         if ((phone_lock_view_data->view_disabled == 0)
2032             && (phone_lock_view_data->is_customedentry_clicked == EINA_TRUE)) {
2033                 switch (phone_lock_view_data->lock_type) {
2034                 case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
2035                         evas_object_show(phone_lock_view_data->input_entry);
2036                         elm_object_focus_set(phone_lock_view_data->input_entry,
2037                                              EINA_TRUE);
2038                         imf_context =
2039                             elm_entry_imf_context_get
2040                             (phone_lock_view_data->input_entry);
2041                         if (imf_context) {
2042                                 ecore_imf_context_input_panel_show(imf_context);
2043                         }
2044                         break;
2045                 case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
2046                         PHONE_LOCK_DBG("");
2047                         evas_object_show
2048                             (phone_lock_view_data->editfield_layout);
2049                         elm_object_focus_set
2050                             (_phone_lock_view_editfield_entry_get
2051                              (phone_lock_view_data->editfield_layout),
2052                              EINA_TRUE);
2053                         imf_context =
2054                             elm_entry_imf_context_get
2055                             (_phone_lock_view_editfield_entry_get
2056                              (phone_lock_view_data->editfield_layout));
2057                         if (imf_context) {
2058                                 ecore_imf_context_input_panel_show(imf_context);
2059                         }
2060                         break;
2061                 default:
2062                         break;
2063                 }
2064         }
2065 }
2066
2067 void phone_lock_view_check_attempts_left(void *data)
2068 {
2069         phone_lock_view_data_t *phone_lock_view_data =
2070             (phone_lock_view_data_t *) data;
2071         PHONE_LOCK_DBG("%s", __FUNCTION__);
2072
2073         int value = -1;
2074
2075         vconf_get_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT, &value);
2076         value--;
2077
2078         if (value > 0 && value <= PHONE_LOCK_VIEW_PHONE_LOCK_ATTEMPTS_MAX) {
2079                 char temp_str[200] = { 0, };
2080                 char temp_left[50] = { 0, };
2081
2082                 vconf_set_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
2083                               value);
2084                 snprintf(temp_left, 50,
2085                          phone_lock_get_string(IDS_IDLE_BODY_PD_ATTEMPTS_LEFT),
2086                          value);
2087                 snprintf(temp_str, 200, "%s, %s",
2088                          phone_lock_get_string(IDS_IDLE_BODY_WRONG_PASSWORD),
2089                          temp_left);
2090                 phone_lock_view_show_msg(phone_lock_view_data, temp_str);
2091         } else if (value == 0) {
2092                 time_t cur_time = time(NULL);
2093                 char cur_timestamp[64] = { 0, };
2094
2095                 snprintf(cur_timestamp, sizeof(cur_timestamp), "%ld", cur_time);
2096                 vconf_set_str(VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR,
2097                               cur_timestamp);
2098                 vconf_set_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
2099                               value);
2100                 phone_lock_view_data->block_seconds = PHONE_LOCK_VIEW_PHONE_LOCK_BLOCK_SECONDS; /* set the initial value for block seconds */
2101                 phone_lock_view_data->view_disabled = 1;
2102                 switch (phone_lock_view_data->lock_type) {
2103                 case PHONE_LOCK_VIEW_COMPLEX_PHONE_LOCK:
2104                         _phone_lock_view_disable_phone_lock
2105                             (phone_lock_view_data);
2106                         break;
2107                 case PHONE_LOCK_VIEW_SIMPLE_PHONE_LOCK:
2108                         _phone_lock_view_disable_simple_phone_lock
2109                             (phone_lock_view_data);
2110                         break;
2111                 default:
2112                         break;
2113                 }
2114                 phone_lock_view_show_msg(phone_lock_view_data,
2115                                          phone_lock_get_string
2116                                          (IDS_IDLE_BODY_INPUT_PASSWORD_AFTER_THIRTYSECONDS));
2117         }
2118 }
2119
2120 void phone_lock_view_reset_attempts_num(void *data)
2121 {
2122         phone_lock_view_data_t *phone_lock_view_data =
2123             (phone_lock_view_data_t *) data;
2124         PHONE_LOCK_DBG("%s", __FUNCTION__);
2125
2126         if (phone_lock_view_data == NULL) {
2127                 return;
2128         }
2129         vconf_ignore_key_changed(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
2130                                  _phone_lock_view_check_vconf_value_cb);
2131         vconf_set_int(VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT,
2132                       PHONE_LOCK_VIEW_PHONE_LOCK_ATTEMPTS_MAX);
2133 }
2134
2135 void phone_lock_view_reset_callug_launch_flag(void *data)
2136 {
2137         phone_lock_view_data_t *phone_lock_view_data =
2138             (phone_lock_view_data_t *) data;
2139         PHONE_LOCK_DBG("%s", __FUNCTION__);
2140
2141         if (phone_lock_view_data == NULL) {
2142                 return;
2143         }
2144         phone_lock_view_data->is_callug_launched = EINA_FALSE;
2145 }
2146
2147 void phone_lock_view_set_right_password_flag(void *data)
2148 {
2149         phone_lock_view_data_t *phone_lock_view_data =
2150             (phone_lock_view_data_t *) data;
2151         PHONE_LOCK_DBG("%s", __FUNCTION__);
2152
2153         if (phone_lock_view_data == NULL) {
2154                 return;
2155         }
2156         phone_lock_view_data->is_right_password = EINA_TRUE;
2157 }
2158
2159 void
2160 phone_lock_view_show_msg(phone_lock_view_data_t * phone_lock_view_data,
2161                          const char *str)
2162 {
2163         Evas_Object *popup;
2164
2165         PHONE_LOCK_DBG("%s : %d, %p", __FUNCTION__,
2166                        phone_lock_view_data->view_type, phone_lock_view_data);
2167
2168         popup = elm_popup_add(phone_lock_view_data->win_main);
2169         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
2170                                          EVAS_HINT_EXPAND);
2171
2172         evas_object_smart_callback_add(popup, "block,clicked",
2173                         _phone_lock_view_block_clicked_cb, phone_lock_view_data);
2174         elm_popup_timeout_set(popup, 3);
2175
2176         elm_object_text_set(popup, str);
2177
2178         evas_object_smart_callback_add(popup, "timeout",
2179                         _phone_lock_view_popup_timeout_cb, phone_lock_view_data);
2180         evas_object_show(popup);
2181 }