setting-password/src/setting-password-main.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
   5  *
   6  * This file is part of org.tizen.setting
   7  * Written by Hyejin Kim <hyejin0906.kim@samsung.com>
   8  *
   9  * PROPRIETARY/CONFIDENTIAL
  10  *
  11  * This software is the confidential and proprietary information of
  12  * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  13  * disclose such Confidential Information and shall use it only in
  14  * accordance with the terms of the license agreement you entered
  15  * into with SAMSUNG ELECTRONICS.
  16  *
  17  * SAMSUNG make no representations or warranties about the suitability
  18  * of the software, either express or implied, including but not limited
  19  * to the implied warranties of merchantability, fitness for a particular
  20  * purpose, or non-infringement. SAMSUNG shall not be liable for any
  21  * damages suffered by licensee as a result of using, modifying or
  22  * distributing this software or its derivatives.
  23  *
  24  */
  25
  26 #include <setting-password.h>
  27 #include <setting-password-main.h>
  28 #include <openssl/sha.h>
  29
  30 static int setting_password_main_create(void *cb);
  31 static int setting_password_main_destroy(void *cb);
  32 static int setting_password_main_update(void *cb);
  33 static int setting_password_main_cleanup(void *cb);
  34
  35 setting_view setting_view_password_main = {
  36         .create = setting_password_main_create,
  37         .destroy = setting_password_main_destroy,
  38         .update = setting_password_main_update,
  39         .cleanup = setting_password_main_cleanup,
  40 };
  41
  42 /** @todo add i18n supports */
  43 const char *sp_titles[5] = { "IDS_ST_BODY_ENTER_PASSWORD",
  44                 "IDS_ST_BODY_ENTER_NEW_PASSWORD",
  45                 "IDS_ST_BODY_ENTER_PASSWORD_AGAIN",
  46                 "IDS_ST_BODY_ENTER_CURRENT_PASSWORD",
  47                 NULL
  48 };
  49 #define SETTING_SP_TITLE_INDEX_START 0
  50 #define SETTING_SP_TITLE_INDEX_MAX 3
  51
  52 #define ENTRY_CALLBACK_REPEAT_MAX 3
  53 #define SETTING_COMPARE_PW_FAIL -2
  54
  55 static void _sp_changed_cb1(void *data, Evas_Object *obj, void *event_info);
  56 static void _sp_changed_cb2(void *data, Evas_Object *obj, void *event_info);
  57 static void _sp_changed_cb3(void *data, Evas_Object *obj, void *event_info);
  58 static void _sp_changed_cb4(void *data, Evas_Object *obj, void *event_info);
  59
  60 /* ***************************************************
  61  *
  62  *basic func
  63  *
  64  ***************************************************/
  65 static void
  66 __password_main_gl_mouse_up(void *data, Evas *e, Evas_Object *obj,
  67                             void *event)
  68 {
  69         ret_if(!data);
  70         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  71         if (ad->ed_pw1) {
  72                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  73         }
  74         if (ad->ed_pw2) {
  75                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  76         }
  77         if (ad->ed_pw3) {
  78                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  79         }
  80
  81 }
  82
  83 static char *setting_password_main_get_title_str(void *data)
  84 {
  85         retvm_if(data == NULL, NULL,
  86                  "[Setting > Password] Data parameter is NULL");
  87         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  88         char title[MAX_DISPLAY_NAME_LEN_ON_UI] ={0,};
  89
  90         switch (ad->view_type) {
  91         case SETTING_PW_TYPE_POWER_ON_LOCK:
  92         case SETTING_PW_TYPE_PHONE_LOCK:
  93         case SETTING_PW_TYPE_RESET:
  94         case SETTING_PW_TYPE_CLEAR:
  95         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
  96         case SETTING_PW_TYPE_CHANGE_PASSWORD:
  97                 return _("IDS_COM_BODY_AUTH_PASSWORD");
  98                 break;
  99         case SETTING_PW_TYPE_SET_PASSWORD:
 100                 if(safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_LOCK_FOR_APP") == 0)
 101                 {
 102                         snprintf(title, sizeof(title), "%s %s", _("IDS_ST_BODY_PHONE_LOCK"), _("IDS_COM_BODY_AUTH_PASSWORD"));
 103                         return strdup(title);
 104                 }
 105                 else
 106                 {
 107                         return _("IDS_COM_BODY_AUTH_PASSWORD");
 108                 }
 109                 break;
 110         case SETTING_PW_TYPE_LOCK_FOR_APP:
 111                 snprintf(title, sizeof(title), "%s %s", _("IDS_ST_BODY_PHONE_LOCK"), _("IDS_COM_BODY_AUTH_PASSWORD"));
 112                 return strdup(title);
 113                 break;
 114         case SETTING_PW_TYPE_SIM_LOCK_ON:
 115         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 116                 return _("IDS_COM_BODY_AUTH_PASSWORD");
 117                 break;
 118         case SETTING_PW_TYPE_PIN_LOCK_ON:
 119         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 120                 return _("IDS_ST_BODY_PIN1");
 121                 break;
 122         case SETTING_PW_TYPE_CHANGE_PIN1:
 123                 return _("IDS_ST_BODY_CHANGE_PIN1");
 124                 break;
 125
 126         case SETTING_PW_TYPE_FDN_MODE_ON:
 127         case SETTING_PW_TYPE_FDN_MODE_OFF:
 128                 return _("IDS_ST_BODY_PIN2");
 129                 break;
 130
 131         case SETTING_PW_TYPE_CHANGE_PIN2:
 132                 return _("IDS_ST_BODY_CHANGE_PIN2");
 133                 break;
 134
 135         case SETTING_PW_TYPE_PIN1_BLOCKED:
 136                 return _("IDS_ST_BODY_PUK1_CODE");
 137                 break;
 138         case SETTING_PW_TYPE_PIN2_BLOCKED:
 139
 140                 return _("IDS_ST_BODY_PUK2");
 141                 break;
 142         default:
 143                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
 144                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 145                 break;
 146         }
 147         return NULL;
 148
 149 }
 150
 151 static void
 152 _sp_back_key_up(void *data, Evas *e, Evas_Object *obj, void *event)
 153 {
 154         retm_if(data == NULL || event == NULL, "[Setting > Password] Data parameter is NULL");
 155
 156         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 157
 158         ret_if(ad->sp_focused == NULL || ad->sp_entry1 == NULL || ad->sp_entry2 == NULL
 159                         || ad->sp_entry3 == NULL || ad->sp_entry4 == NULL);
 160
 161         Evas_Object *cur_entry = NULL;
 162         Evas_Object *move_to = NULL;
 163
 164         Evas_Event_Key_Up *ev = (Evas_Event_Key_Up*)event;
 165
 166         cur_entry = ad->sp_focused;
 167
 168         if(cur_entry == ad->sp_entry1)
 169         {
 170                 /* nothing to move. */
 171                 return;
 172         }
 173         else if(cur_entry == ad->sp_entry2)
 174         {
 175                 move_to = ad->sp_entry1;
 176         }
 177         else if(cur_entry == ad->sp_entry3)
 178         {
 179                 move_to = ad->sp_entry2;
 180         }
 181         else if(cur_entry == ad->sp_entry4)
 182         {
 183                 move_to = ad->sp_entry3;
 184         }
 185         else
 186         {
 187                 return;
 188         }
 189
 190         if(strcmp(ev->keyname, "BackSpace") == 0)
 191         {
 192                 elm_object_focus_set(move_to, EINA_TRUE);
 193                 elm_entry_entry_set(move_to, "<font_size=52 align=center>");
 194                 elm_entry_cursor_end_set(move_to);
 195                 ad->sp_focused = move_to;
 196         }
 197 }
 198
 199 Elm_Object_Item* __create_navi_bar_with_left_button(void *data, Evas_Object *content, Evas_Object *navibar)
 200 {
 201         retv_if(data == NULL || content == NULL || navibar == NULL, NULL);
 202
 203         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 204
 205         Elm_Object_Item *navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 206                                                                         _("IDS_COM_SK_CANCEL"), NULL, NULL,
 207                                                                         setting_password_main_click_softkey_cancel_cb,
 208                                                                         setting_password_main_click_softkey_done_cb,
 209                                                                         NULL, ad, content, navibar);
 210         retv_if(!navi_item, NULL);
 211         return navi_item;
 212 }
 213
 214 Elm_Object_Item* __create_navi_bar_with_both_button(void *data, Evas_Object *content, Evas_Object *navibar)
 215 {
 216         retv_if(data == NULL || content == NULL || navibar == NULL, NULL);
 217
 218         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 219
 220         Elm_Object_Item *navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 221                                                                         _("IDS_COM_SK_CANCEL"), _("IDS_COM_SK_DONE"), NULL,
 222                                            setting_password_main_click_softkey_cancel_cb,
 223                                                                         setting_password_main_click_softkey_done_cb,
 224                                                                         NULL, ad, content, navibar);
 225
 226         retv_if(!navi_item, NULL);
 227
 228         Evas_Object *done_btn = elm_object_item_part_content_get(navi_item, "title_right_btn");
 229         if(done_btn != NULL)
 230         {
 231         setting_disable_evas_object(done_btn);
 232         setting_dim_evas_object(done_btn, TRUE);
 233         }
 234         return navi_item;
 235 }
 236
 237 static int __create_common_password_frame(void *data)
 238 {
 239         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 240
 241         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 242         Evas_Object *navi_bar = NULL;
 243         static int count = 0;
 244
 245         count++;
 246         /* CONTENT */
 247         if(ad->scroller != NULL)
 248         {
 249                 evas_object_del(ad->scroller);
 250         }
 251
 252         Evas_Object *pw_list = elm_genlist_add(ad->win_main_layout);
 253         if(pw_list == NULL)
 254                 return SETTING_RETURN_FAIL;
 255
 256         elm_genlist_clear(pw_list);     /* first to clear list */
 257         elm_genlist_homogeneous_set(pw_list, EINA_TRUE);
 258         elm_genlist_mode_set(pw_list, ELM_LIST_COMPRESS);
 259
 260
 261 #if SUPPORT_BOTTOM_BTNS
 262         ad->ly_main = setting_create_win_layout(ad->win_main_layout, ad->win_get);
 263         retv_if(!ad->ly_main, SETTING_RETURN_FAIL);
 264
 265         navi_bar = setting_create_navi_bar(ad->ly_main);
 266         retv_if(!navi_bar, SETTING_RETURN_FAIL);
 267
 268
 269         if((ad->is_simple_password_on == 1) &&
 270                 ((ad->view_type == SETTING_PW_TYPE_PHONE_LOCK)
 271                         || (ad->view_type == SETTING_PW_TYPE_SET_PASSWORD)
 272                         || (ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
 273                         || (ad->view_type == SETTING_PW_TYPE_CHANGE_PASSWORD)
 274                         || (ad->view_type == SETTING_PW_TYPE_RESET)
 275                         || (ad->view_type == SETTING_PW_TYPE_LOCK_FOR_APP) ))
 276         {
 277                 if((ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD) && count == 2)
 278                 {
 279                         /* from simple password to normal password */
 280                         ad->navi_it = __create_navi_bar_with_both_button(ad, pw_list, navi_bar);
 281                 }
 282                 else
 283                 {
 284                         ad->navi_it = __create_navi_bar_with_left_button(ad, pw_list, navi_bar);
 285                 }
 286         }
 287         else
 288         {
 289                 if((ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD) && count == 2)
 290                 {
 291                         /* from normal password to simple password */
 292                         ad->navi_it = __create_navi_bar_with_left_button(ad, pw_list, navi_bar);
 293                 }
 294                 else
 295                 {
 296                         ad->navi_it = __create_navi_bar_with_both_button(ad, pw_list, navi_bar);
 297                 }
 298         }
 299
 300         retv_if(!ad->navi_it, SETTING_RETURN_FAIL);
 301 #else
 302         ad->ly_main =
 303             setting_create_layout_navi_bar(ad->win_main_layout, ad->win_get,
 304                                            setting_password_main_get_title_str
 305                                            (ad), _("IDS_COM_SK_CANCEL"),
 306                                            _("IDS_COM_SK_DONE"), NULL,
 307                                            setting_password_main_click_softkey_cancel_cb,
 308                                            setting_password_main_click_softkey_done_cb,
 309                                            NULL, ad, pw_list /* contents */ ,
 310                                            &navi_bar, &(ad->controllbar));
 311         elm_object_item_disabled_set(elm_toolbar_last_item_get(ad->controllbar), EINA_TRUE);
 312
 313         if(ad->ly_main == NULL)
 314                 return SETTING_RETURN_FAIL;
 315 #endif
 316
 317         evas_object_event_callback_add(pw_list, EVAS_CALLBACK_MOUSE_UP,
 318                                        __password_main_gl_mouse_up, ad);
 319
 320         Elm_Object_Item *item = elm_genlist_item_append(pw_list,
 321                                                                 &(ad->itc_seperator), NULL, NULL,
 322                                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 323         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 324
 325         ad->scroller = pw_list;
 326
 327         return SETTING_RETURN_SUCCESS;
 328 }
 329
 330 static void _copy_chars_from_sp_entries(void *data, char *collection)
 331 {
 332         ret_if(data == NULL || collection == NULL);
 333
 334         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 335
 336         if(ad->sp_entry1 == NULL || ad->sp_entry2 == NULL ||
 337                 ad->sp_entry3 == NULL || ad->sp_entry4 == NULL)
 338                 return;
 339
 340         strncpy(&collection[0], elm_entry_entry_get(ad->sp_entry1), 1);
 341         strncpy(&collection[1], elm_entry_entry_get(ad->sp_entry2), 1);
 342         strncpy(&collection[2], elm_entry_entry_get(ad->sp_entry3), 1);
 343         strncpy(&collection[3], elm_entry_entry_get(ad->sp_entry4), 1);
 344 }
 345
 346 static int _handle_step1(void *data, char *collection)
 347 {
 348         retv_if(data == NULL, SETTING_RETURN_FAIL);
 349
 350         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 351         int ret = 0;
 352         int err = 0;
 353
 354         char svalue[SHA256_DIGEST_LENGTH];
 355         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 356
 357         _copy_chars_from_sp_entries(ad, collection);
 358
 359         ret = setting_password_main_check_simple_password(collection);
 360         if(ret < 0)
 361         {
 362                 setting_password_main_draw_simple_password(ad, 3);
 363                 return SETTING_RETURN_FAIL;
 364         }
 365
 366         ret = setting_password_check_password(collection);
 367         if(ret != SETTING_RETURN_SUCCESS)
 368         {
 369                 setting_password_main_draw_simple_password(ad, 3);
 370                 return SETTING_COMPARE_PW_FAIL;
 371         }
 372
 373         /* reset static variables */
 374         memset(collection, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 375
 376         int value = 0;
 377
 378         if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PHONE_LOCK"))
 379         {
 380                 setting_get_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK, &value, &err);
 381                 SETTING_TRACE_DEBUG("get VCONF POWER_ON_LOCK : %d", value);
 382
 383                 if (value == 0)
 384                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 385                                                      SETTING_ON_OFF_BTN_ON, &err);
 386                 else
 387                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 388                                                      SETTING_ON_OFF_BTN_OFF, &err);
 389
 390                 /* reset VCONF */
 391                 setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,
 392                                      PHONE_LOCK_ATTEMPS_MAX, &err);
 393                 setting_retvm_if(err == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
 394
 395                 /* Correct Password. Send Bundle to caller for status change */
 396         }
 397
 398         bundle *b = bundle_create();
 399         if (!b)
 400         {
 401                 setting_password_main_draw_simple_password(ad, 3);
 402                 return SETTING_RETURN_FAIL;
 403         }
 404
 405         bundle_add(b, "result", ad->view_type_string);
 406         ug_send_result(ad->ug, b);
 407         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 408         bundle_free(b);
 409         /* Send destroy request */
 410         ug_destroy_me(ad->ug);
 411
 412         return SETTING_RETURN_SUCCESS;
 413 }
 414
 415 static int _handle_step_sp(void *data, int *step, char *collection1, char *collection2)
 416 {
 417         retv_if(data == NULL, SETTING_RETURN_FAIL);
 418
 419         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 420         int ret = 0;
 421
 422         char svalue[SHA256_DIGEST_LENGTH];
 423         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 424
 425         if(ad->is_simple_password_on == 1)
 426         {
 427                 SETTING_TRACE_DEBUG("case ON->OFF");
 428                 _copy_chars_from_sp_entries(ad, collection1);
 429
 430                 ret = setting_password_main_check_simple_password(collection1);
 431                 if(ret < 0)
 432                 {
 433                         setting_password_main_draw_simple_password(ad, 3);
 434                         return SETTING_RETURN_FAIL;
 435                 }
 436
 437                 SETTING_TRACE_DEBUG("collection_step1 : %s", collection1);
 438
 439                 ret = setting_password_check_password(collection1);
 440                 if(ret != SETTING_RETURN_SUCCESS)
 441                 {
 442                         setting_password_main_draw_simple_password(ad, 3);
 443                         return SETTING_RETURN_FAIL;
 444                 }
 445                 ad->cur_pwd = (char*)strdup(collection1);
 446
 447                 /* reset static variables */
 448                 memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 449
 450                 if(ad->sp_entry1 == NULL || ad->sp_entry2 == NULL || ad->sp_entry3 == NULL || ad->sp_entry4 == NULL)
 451                         return SETTING_RETURN_FAIL;
 452
 453                 evas_object_event_callback_del(ad->sp_entry1, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 454                 evas_object_event_callback_del(ad->sp_entry2, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 455                 evas_object_event_callback_del(ad->sp_entry3, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 456                 evas_object_event_callback_del(ad->sp_entry4, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 457
 458                 evas_object_smart_callback_del(ad->sp_entry1, "changed", _sp_changed_cb1);
 459                 evas_object_smart_callback_del(ad->sp_entry2, "changed", _sp_changed_cb2);
 460                 evas_object_smart_callback_del(ad->sp_entry3, "changed", _sp_changed_cb3);
 461                 evas_object_smart_callback_del(ad->sp_entry4, "changed", _sp_changed_cb4);
 462
 463                 if(ad->ly_main)
 464                 {
 465                         evas_object_del(ad->ly_main);
 466                         ad->ly_main = NULL;
 467                 }
 468                 if(ad->remove_timer)
 469                 {
 470                         ecore_timer_del(ad->remove_timer);
 471                         ad->remove_timer = NULL;
 472                 }
 473
 474                 __create_common_password_frame(ad);
 475                 setting_password_main_draw_2line_password(ad, NULL);
 476         }
 477         else if(ad->is_simple_password_on == 0)
 478         {
 479                 SETTING_TRACE_DEBUG("case OFF->ON");
 480                 if(*step == 0) /* Enter new password */
 481                 {
 482                         _copy_chars_from_sp_entries(ad, collection1);
 483
 484                         ret = setting_password_main_check_simple_password(collection1);
 485                         if(ret < 0)
 486                         {
 487                                 setting_password_main_draw_simple_password(ad, 1);
 488                                 return SETTING_RETURN_FAIL;
 489                         }
 490                         (*step)++;
 491                         setting_password_main_draw_next_simple_password(ad, 2);
 492                 }
 493                 else if(*step == 1)     /* Enter password again */
 494                 {
 495                         _copy_chars_from_sp_entries(ad, collection2);
 496
 497                         ret = setting_password_main_check_simple_password(collection2);
 498                         if(ret < 0)
 499                         {
 500                                 setting_password_main_draw_simple_password(ad, 2);
 501                                 return SETTING_RETURN_FAIL;
 502                         }
 503
 504                         SETTING_TRACE_DEBUG("collection_step1 : %s", collection1);
 505                         SETTING_TRACE_DEBUG("collection_step2 : %s", collection2);
 506
 507                         /* compare two input passwords : collection_step1, collection_step2 */
 508                         if(safeStrNCmp(collection1, collection2, 4) == 0)
 509                         {
 510                                 ret = setting_password_set_password(ad->cur_pwd, collection1, ad);
 511                                 FREE(ad->cur_pwd);
 512
 513                                 /* Modify Setting Password */
 514                                 if (SETTING_RETURN_SUCCESS == ret) {
 515                                         SETTING_TRACE_DEBUG("success to save new password");
 516
 517                                         /* set vconfkey ON : if fail, try one more time. */
 518                                         if(vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, 1) < 0)
 519                                                 return SETTING_RETURN_FAIL;
 520                                         else
 521                                                 SETTING_TRACE_DEBUG("set vconfkey : simple password is ON");
 522
 523                                         /* Display popup */
 524                                         setting_password_ug_create_popup_notitle_nobtn(ad,
 525                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
 526
 527                                         *step = 0;
 528                                         /* reset static variables */
 529                                         memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 530                                         memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 531
 532                                         /* Correct Password. Send Bundle to caller for status change */
 533                                         bundle *b = bundle_create();
 534                                         if (!b)
 535                                         {
 536                                                 setting_password_main_draw_simple_password(ad, 2);
 537                                                 return SETTING_RETURN_FAIL;
 538                                         }
 539
 540                                         bundle_add(b, "result", ad->view_type_string);
 541                                         ug_send_result(ad->ug, b);
 542                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 543                                         bundle_free(b);
 544                                         /* Send destroy request */
 545                                         ug_destroy_me(ad->ug);
 546                                 }
 547                                 else
 548                                 {
 549                                         setting_password_main_draw_simple_password(ad, 2);
 550                                         return SETTING_RETURN_FAIL;
 551                                 }
 552                         }
 553                         else
 554                         {
 555                                 setting_password_main_draw_simple_password(ad, 2);
 556                                 return SETTING_RETURN_FAIL;
 557                         }
 558                 }
 559         }
 560
 561         return SETTING_RETURN_SUCCESS;
 562 }
 563
 564 static int _handle_step2(void *data, int *step, char *collection1, char*collection2)
 565 {
 566         retv_if(data == NULL, SETTING_RETURN_FAIL);
 567
 568         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 569         int ret = 0;
 570
 571         if(*step == 0)  /* Enter new password */
 572         {
 573                 _copy_chars_from_sp_entries(ad, collection1);
 574
 575                 ret = setting_password_main_check_simple_password(collection1);
 576                 if(ret < 0)
 577                 {
 578                         setting_password_main_draw_simple_password(ad, 2);
 579                         return SETTING_RETURN_FAIL;
 580                 }
 581                 (*step)++;
 582                 setting_password_main_draw_next_simple_password(ad, 2);
 583         }
 584         else if(*step == 1)     /* Enter password again */
 585         {
 586                 _copy_chars_from_sp_entries(ad, collection2);
 587
 588                 ret = setting_password_main_check_simple_password(collection2);
 589                 if(ret < 0)
 590                 {
 591                         setting_password_main_draw_simple_password(ad, 2);
 592                         return SETTING_RETURN_FAIL;
 593                 }
 594
 595                 /* compare two input passwords : collection_step1, collection_step2 */
 596                 if(safeStrNCmp(collection1, collection2, 4) == 0)
 597                 {
 598                         ret = setting_password_set_password(NULL, collection1, ad);
 599
 600                         if (SETTING_RETURN_SUCCESS == ret) {
 601                                 if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PHONE_LOCK"))
 602                                 {
 603                                         int err;
 604                                         int ret;
 605
 606                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 607                                                                                                 SETTING_ON_OFF_BTN_ON, &err);
 608                                         retvm_if(ret < 0, SETTING_RETURN_FAIL, "[ERR] setting vconfkey failed.");
 609
 610                                         bundle *b = bundle_create();
 611                                         if (!b)
 612                                                 return SETTING_RETURN_FAIL;
 613
 614                                         bundle_add(b, "result", "SETTING_PW_TYPE_PHONE_LOCK");
 615                                         ug_send_result(ad->ug, b);
 616                                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_PHONE_LOCK");
 617                                         bundle_free(b);
 618                                 }
 619                                 else if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_LOCK_FOR_APP"))
 620                                 {
 621                                         bundle *b = bundle_create();
 622                                         if (!b)
 623                                                 return SETTING_RETURN_FAIL;
 624
 625                                         bundle_add(b, "result", "SETTING_PW_TYPE_LOCK_FOR_APP");
 626                                         ug_send_result(ad->ug, b);
 627                                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_LOCK_FOR_APP");
 628                                         bundle_free(b);
 629                                 }
 630                                 /* Display popup */
 631                                 setting_password_ug_create_popup_notitle_nobtn(ad,
 632                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
 633                         }
 634
 635                         *step = 0;
 636                         /* reset static variables */
 637                         memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 638                         memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 639                         /* Send destroy request */
 640                         ug_destroy_me(ad->ug);
 641                 }
 642                 else
 643                 {
 644                         setting_password_main_draw_simple_password(ad, 2);
 645                         return SETTING_RETURN_FAIL;
 646                 }
 647         }
 648         return SETTING_RETURN_SUCCESS;
 649 }
 650
 651 static int _handle_step3(void *data, int *step, char *collection1, char *collection2, char *collection3)
 652 {
 653         retv_if(data == NULL, SETTING_RETURN_FAIL);
 654
 655         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 656         int ret = 0;
 657         int err = 0;
 658
 659         char svalue[SHA256_DIGEST_LENGTH];
 660         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 661
 662         if(*step == 0)  /* Enter current password */
 663         {
 664                 _copy_chars_from_sp_entries(ad, collection1);
 665
 666                 ret = setting_password_main_check_simple_password(collection1);
 667                 if(ret < 0)
 668                 {
 669                         setting_password_main_draw_simple_password(ad, 3);
 670                         return SETTING_RETURN_FAIL;
 671                 }
 672
 673                 ret = setting_password_check_password(collection1);
 674                 if(ret != SETTING_RETURN_SUCCESS)
 675                 {
 676                         setting_password_main_draw_simple_password(ad, 3);
 677                         return SETTING_RETURN_FAIL;
 678                 }
 679                 (*step)++;
 680                 setting_password_main_draw_next_simple_password(ad, 1);
 681         }
 682         else if(*step == 1)     /* Enter new password */
 683         {
 684                 _copy_chars_from_sp_entries(ad, collection2);
 685
 686                 ret = setting_password_main_check_simple_password(collection2);
 687                 if(ret < 0)
 688                 {
 689                         setting_password_main_draw_simple_password(ad, 1);
 690                         return SETTING_RETURN_FAIL;
 691                 }
 692
 693                 (*step)++;
 694                 setting_password_main_draw_next_simple_password(ad, 2);
 695         }
 696         else if(*step == 2)     /* Enter password again */
 697         {
 698                 _copy_chars_from_sp_entries(ad, collection3);
 699
 700                 ret = setting_password_main_check_simple_password(collection3);
 701                 if(ret < 0)
 702                 {
 703                         setting_password_main_draw_simple_password(ad, 2);
 704                         return SETTING_RETURN_FAIL;
 705                 }
 706
 707                 /* compare two input passwords : collection_step1, collection_step2 */
 708                 if(safeStrNCmp(collection2, collection3, 4) == 0)
 709                 {
 710                         ret = setting_password_set_password(collection1, collection2, ad);
 711                         /* Modify Setting Password */
 712                         if (SETTING_RETURN_FAIL != ret) {
 713                                 /* Display popup */
 714                                 setting_password_ug_create_popup_notitle_nobtn(ad,
 715                                                                         _("IDS_ST_POP_PASSWORD_CHANGED"), TRUE);
 716                         } else {
 717                                 /* Error Msg */
 718                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
 719                                                                         SETTING_FONT_RED, err, SETTING_FONT_BLACK);
 720                                 setting_password_ug_create_popup_notitle_nobtn(ad,
 721                                                                                 _("IDS_COM_POP_ERROR"), FALSE);
 722                         }
 723                 }
 724                 else
 725                 {
 726                         setting_password_main_draw_simple_password(ad, 2);
 727                         return SETTING_RETURN_FAIL;
 728                 }
 729                 *step = 0;
 730                 /* reset static variables */
 731                 memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 732                 memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 733                 memset(collection3, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 734
 735                 /* Send destroy request */
 736                 ug_destroy_me(ad->ug);
 737         }
 738         return SETTING_RETURN_SUCCESS;
 739 }
 740
 741 static int setting_password_main_done_simple_password(void *data, int on_locking)
 742 {
 743         SETTING_TRACE_BEGIN;
 744         retv_if(data == NULL, SETTING_RETURN_FAIL);
 745
 746         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 747
 748         static int step = 0;
 749
 750         static char collection_step1[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 751         static char collection_step2[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 752         static char collection_step3[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 753
 754         switch(ad->view_type)
 755         {
 756                 case SETTING_PW_TYPE_RESET:
 757                 case SETTING_PW_TYPE_LOCK_FOR_APP:
 758                 case SETTING_PW_TYPE_PHONE_LOCK:        /* Enter a password */
 759                         SETTING_TRACE_DEBUG("case PHONE_LOCK");
 760                         if(on_locking == 0)
 761                                 return SETTING_RETURN_FAIL;
 762
 763                         return _handle_step1(ad, collection_step1);
 764                         break;
 765                 case SETTING_PW_TYPE_SIMPLE_PASSWORD:
 766                         SETTING_TRACE_DEBUG("case SIMPLE_PASSWORD");
 767                         return _handle_step_sp(ad, &step, collection_step1, collection_step2);
 768                         break;
 769                 case SETTING_PW_TYPE_SET_PASSWORD:
 770                         SETTING_TRACE_DEBUG("case SET_PASSWORD");
 771                         return _handle_step2(ad, &step, collection_step1, collection_step2);
 772                         break;
 773                 case SETTING_PW_TYPE_CHANGE_PASSWORD:
 774                         SETTING_TRACE_DEBUG("case CHANGE_PASSWORD");
 775                         return _handle_step3(ad, &step, collection_step1, collection_step2, collection_step3);
 776                         break;
 777                 default:
 778                         break;
 779         }
 780         return SETTING_RETURN_SUCCESS;
 781 }
 782
 783 static void _sp_changed_cb1(void *data, Evas_Object *obj, void *event_info)
 784 {
 785         ret_if(data == NULL);
 786
 787         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 788
 789         if((ad->sp_entry1 == NULL) || (ad->sp_entry1 != obj) || (ad->sp_entry2 == NULL))
 790                 return;
 791
 792         if(!elm_entry_is_empty(ad->sp_entry1) && elm_entry_is_empty(ad->sp_entry2))
 793         {
 794                 SETTING_TRACE_DEBUG("entry1 : %s", elm_entry_entry_get(ad->sp_entry1));
 795                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry1), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 796                         return;
 797                 /* focus on next entry */
 798                 elm_object_focus_set(ad->sp_entry2, EINA_TRUE);
 799                 elm_entry_entry_set(ad->sp_entry2, "<font_size=52 align=center>");
 800                 elm_entry_cursor_end_set(ad->sp_entry2);
 801                 ad->sp_focused = ad->sp_entry2;
 802         }
 803 }
 804
 805 static void _sp_changed_cb2(void *data, Evas_Object *obj, void *event_info)
 806 {
 807         ret_if(data == NULL);
 808
 809         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 810
 811         if((ad->sp_entry2 == NULL) || (ad->sp_entry2 != obj) || (ad->sp_entry3 == NULL))
 812                 return;
 813
 814         if(!elm_entry_is_empty(ad->sp_entry2) && elm_entry_is_empty(ad->sp_entry3))
 815         {
 816                 SETTING_TRACE_DEBUG("entry2 : %s", elm_entry_entry_get(ad->sp_entry2));
 817                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry2), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 818                         return;
 819                 /* focus on next entry */
 820                 elm_object_focus_set(ad->sp_entry3, EINA_TRUE);
 821                 elm_entry_entry_set(ad->sp_entry3, "<font_size=52 align=center>");
 822                 elm_entry_cursor_end_set(ad->sp_entry3);
 823                 ad->sp_focused = ad->sp_entry3;
 824         }
 825 }
 826
 827 static void _sp_changed_cb3(void *data, Evas_Object *obj, void *event_info)
 828 {
 829         ret_if(data == NULL);
 830
 831         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 832
 833         if((ad->sp_entry3 == NULL) || (ad->sp_entry3 != obj) || (ad->sp_entry4 == NULL))
 834                 return;
 835
 836         if(!elm_entry_is_empty(ad->sp_entry3) && elm_entry_is_empty(ad->sp_entry4))
 837         {
 838                 SETTING_TRACE_DEBUG("entry3 : %s", elm_entry_entry_get(ad->sp_entry3));
 839                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry3), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 840                         return;
 841                 /* focus on next entry */
 842                 elm_object_focus_set(ad->sp_entry4, EINA_TRUE);
 843                 elm_entry_entry_set(ad->sp_entry4, "<font_size=52 align=center>");
 844                 elm_entry_cursor_end_set(ad->sp_entry4);
 845                 ad->sp_focused = ad->sp_entry4;
 846         }
 847 }
 848
 849 static void _sp_changed_cb4(void *data, Evas_Object *obj, void *event_info)
 850 {
 851         ret_if(data == NULL);
 852
 853         static int counter = 0;
 854
 855         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 856
 857         if((ad->sp_entry4 == NULL) || (ad->sp_entry4 != obj))
 858                 return;
 859         if((ad->sp_entry1 == NULL) || (ad->sp_entry2 == NULL) || (ad->sp_entry3 == NULL))
 860                 return;
 861
 862         if(strcmp(elm_entry_entry_get(ad->sp_entry4), "") == 0)
 863         {
 864                 SETTING_TRACE_DEBUG("this is align text");
 865                 return;
 866         }
 867         if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry4), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 868                         return;
 869
 870         SETTING_TRACE_DEBUG("entry4 : %s", elm_entry_entry_get(ad->sp_entry4));
 871         /*  add this below for removing IMF faster */
 872         /*  need to discuss with IMF or Entry developer more */
 873         elm_object_focus_set(ad->sp_entry4, EINA_FALSE);
 874         /* end */
 875         counter++;
 876
 877         if(counter == ENTRY_CALLBACK_REPEAT_MAX)
 878         {
 879                 int ret = 0;
 880
 881                 ret = setting_password_main_done_simple_password(ad, TRUE);
 882
 883                 if(ret == SETTING_RETURN_FAIL)
 884                 {
 885                         setting_password_ug_display_desc(ad, _("IDS_ST_BODY_INCORRECT_PASSWORD_TRY_AGAIN"), FALSE);
 886                 }
 887                 else if(ret == SETTING_COMPARE_PW_FAIL)
 888                 {
 889                         /** @todo setting_password_ug_check_attemps_left */
 890                         setting_int_slp_list item_attempts_left;
 891                         setting_str_slp_list item_lock_timestamp;
 892                         int attemps_left_max = 5;
 893
 894                         item_attempts_left = INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT;
 895                         item_lock_timestamp = STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP;
 896                         attemps_left_max = PHONE_LOCK_ATTEMPS_MAX;
 897
 898                         int value = -1;
 899                         int err = SETTING_RETURN_SUCCESS;
 900                         setting_get_int_slp_key(item_attempts_left, &value, &err);
 901                         setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] get value of vconf fail.");
 902
 903                         value--;
 904
 905                         if (value > 0 && value <= attemps_left_max) {
 906                                 setting_set_int_slp_key(item_attempts_left, value, &err);
 907                                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
 908
 909                                 char speciliztion[MAX_SPECIALIZITION_LEN] = { 0, };
 910                                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
 911
 912                                 if(value > 1)
 913                                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPTS_DESC);
 914                                 else
 915                                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPT_DESC);
 916
 917                                 snprintf(speciliztion, sizeof(speciliztion), temp, value);
 918                                 setting_password_ug_display_desc(ad, speciliztion, FALSE);
 919                         } else if (value == 0) {
 920                                 /*  store the lock timestamp */
 921                                 elm_object_focus_set(ad->sp_entry1, EINA_FALSE);
 922                                 time_t cur_time = time(NULL);
 923                                 char cur_timestamp[LOCK_TIMESTAMP_LEN] = { 0, };
 924                                 int ret = snprintf(cur_timestamp, sizeof(cur_timestamp), "%ld", cur_time);
 925                                 ret_if(ret < 0);
 926
 927                                 setting_set_string_slp_key(item_lock_timestamp, cur_timestamp, &err);
 928                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 929                                                                         "[Error] set value of vconf fail.");
 930
 931                                 setting_set_int_slp_key(item_attempts_left, value, &err);
 932                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 933                                                                         "[Error] set value of vconf fail.");
 934
 935                                 ad->disable_item_type = ad->view_type;
 936
 937                                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
 938                                 snprintf(temp, sizeof(temp), PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
 939                                 setting_password_ug_create_popup_notitle_nobtn(ad, temp, TRUE);
 940                         }
 941                 }
 942                 else
 943                 {
 944                         /* if you have more cases, modify here. */
 945                 }
 946                 counter = 0;
 947                 return;
 948
 949         }
 950         return;
 951 }
 952
 953 static char *__gl_sp_text_get(void *data, Evas_Object *obj, const char *part)
 954 {
 955         retv_if(data == NULL, NULL);
 956         SettingPasswordUG *ad = (SettingPasswordUG*)data;
 957
 958         SETTING_TRACE_DEBUG("[sp_label_get] label intex, %d", ad->sp_title_index);
 959
 960         if(ad->sp_title_index < SETTING_SP_TITLE_INDEX_START || ad->sp_title_index > SETTING_SP_TITLE_INDEX_MAX)
 961         {
 962                 SETTING_TRACE_DEBUG("title index is invalid");
 963                 return NULL;
 964         }
 965         else
 966         {
 967                 return strdup(_(sp_titles[ad->sp_title_index]));
 968         }
 969 }
 970
 971 static Evas_Object* __gl_sp_content_get(void *data, Evas_Object *obj, const char *part)
 972 {
 973         retv_if(data == NULL, NULL);
 974         SettingPasswordUG *ad = (SettingPasswordUG*)data;
 975
 976         Evas_Object *entry = NULL;
 977
 978         static Elm_Entry_Filter_Limit_Size limit_filter_data;
 979         limit_filter_data.max_byte_count = 0;
 980         limit_filter_data.max_char_count = 1;
 981
 982         entry = elm_entry_add(obj);
 983         elm_entry_password_set(entry, EINA_TRUE);
 984         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size, &limit_filter_data);
 985         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
 986         elm_entry_entry_set(entry, "<font_size=52 align=center>");
 987         evas_object_event_callback_add(entry, EVAS_CALLBACK_KEY_UP, _sp_back_key_up, ad);
 988
 989         elm_config_password_show_last_set(EINA_TRUE);
 990         elm_config_password_show_last_timeout_set(0.1);
 991
 992         if(safeStrCmp("elm.icon.1", part) == 0)
 993         {
 994                 SETTING_TRACE_DEBUG("create entry1");
 995                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb1, ad);
 996                 ad->sp_entry1 = entry;
 997         }
 998         else if(safeStrCmp("elm.icon.2", part) == 0)
 999         {
1000                 SETTING_TRACE_DEBUG("create entry2");
1001                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb2, ad);
1002                 ad->sp_entry2 = entry;
1003         }
1004         else if(safeStrCmp("elm.icon.3", part) == 0)
1005         {
1006                 SETTING_TRACE_DEBUG("create entry3");
1007                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb3, ad);
1008                 ad->sp_entry3 = entry;
1009         }
1010         else if(safeStrCmp("elm.icon.4", part) == 0)
1011         {
1012                 SETTING_TRACE_DEBUG("create entry4");
1013                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb4, ad);
1014                 ad->sp_entry4 = entry;
1015         }
1016
1017         return entry;
1018 }
1019
1020 static int
1021 setting_password_main_create(void *cb)
1022 {
1023         SETTING_TRACE_BEGIN;
1024         /* error check */
1025         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1026
1027         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1028         int ret = 0;
1029
1030         ad->itc_sp_bg_1icon.item_style = "dialogue/1text.4icon";
1031         ad->itc_sp_bg_1icon.func.text_get = __gl_sp_text_get;
1032         ad->itc_sp_bg_1icon.func.content_get = __gl_sp_content_get;
1033         ad->itc_sp_bg_1icon.func.state_get = NULL;
1034         ad->itc_sp_bg_1icon.func.del = NULL;
1035
1036                 ret = __create_common_password_frame(ad);
1037
1038         if(ret < 0)
1039                 return SETTING_RETURN_FAIL;
1040
1041         setting_password_main_create_ui(ad);
1042
1043         setting_view_password_main.is_create = 1;
1044         return SETTING_RETURN_SUCCESS;
1045 }
1046
1047 static int setting_password_main_destroy(void *cb)
1048 {
1049         /* error check */
1050         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1051
1052         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1053         if (ad->remove_timer) {
1054                 ecore_timer_del(ad->remove_timer);
1055                 ad->remove_timer = NULL;
1056         }
1057
1058         if((ad->is_simple_password_on == 1) &&
1059                 ((ad->view_type == SETTING_PW_TYPE_PHONE_LOCK)
1060                         || (ad->view_type == SETTING_PW_TYPE_SET_PASSWORD)
1061                         || (ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
1062                         || (ad->view_type == SETTING_PW_TYPE_CHANGE_PASSWORD)
1063                         || (ad->view_type == SETTING_PW_TYPE_RESET)
1064                         || (ad->view_type == SETTING_PW_TYPE_LOCK_FOR_APP) ))
1065         {
1066                 if(ad->sp_entry1)
1067                         evas_object_event_callback_del(ad->sp_entry1, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1068                 if(ad->sp_entry2)
1069                         evas_object_event_callback_del(ad->sp_entry2, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1070                 if(ad->sp_entry3)
1071                         evas_object_event_callback_del(ad->sp_entry3, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1072                 if(ad->sp_entry4)
1073                         evas_object_event_callback_del(ad->sp_entry4, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1074         }
1075
1076         if(ad->scroller)
1077         {
1078                 SETTING_TRACE_DEBUG("delete scroller");
1079                 elm_genlist_clear(ad->scroller);
1080                 evas_object_del(ad->scroller);
1081                 ad->scroller = NULL;
1082         }
1083
1084         if (ad->ly_main != NULL) {
1085                 evas_object_del(ad->ly_main);
1086                 ad->ly_main = NULL;
1087                 setting_view_password_main.is_create = 0;
1088         }
1089
1090         return SETTING_RETURN_SUCCESS;
1091 }
1092
1093 static int setting_password_main_update(void *cb)
1094 {
1095         /* error check */
1096         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1097
1098         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1099
1100         if (ad->ly_main != NULL) {
1101                 evas_object_show(ad->ly_main);
1102         }
1103
1104         return SETTING_RETURN_SUCCESS;
1105 }
1106
1107 static int setting_password_main_cleanup(void *cb)
1108 {
1109         /* error check */
1110         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1111
1112         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1113
1114         if (ad->ly_main != NULL) {
1115                 evas_object_hide(ad->ly_main);
1116         }
1117
1118         return SETTING_RETURN_SUCCESS;
1119 }
1120
1121 /* ***************************************************
1122  *
1123  *general func
1124  *
1125  ***************************************************/
1126
1127 static int setting_password_main_create_ui(void *data)
1128 {
1129         /* error check */
1130         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1131                  "[Setting > Password] Data parameter is NULL");
1132
1133         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1134
1135         SETTING_TRACE_DEBUG("ad->view_type=%d ***", ad->view_type);
1136
1137         switch (ad->view_type) {
1138         case SETTING_PW_TYPE_POWER_ON_LOCK:
1139         case SETTING_PW_TYPE_CLEAR:
1140         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1141         case SETTING_PW_TYPE_PIN_LOCK_ON:
1142         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1143         case SETTING_PW_TYPE_FDN_MODE_ON:
1144         case SETTING_PW_TYPE_FDN_MODE_OFF:
1145                 setting_password_main_draw_1line_password(ad, NULL);
1146                 break;
1147         case SETTING_PW_TYPE_PHONE_LOCK:
1148         case SETTING_PW_TYPE_RESET:
1149         case SETTING_PW_TYPE_LOCK_FOR_APP:
1150                 if(ad->is_simple_password_on == 1)
1151                         setting_password_main_draw_simple_password(ad, 3);
1152                 else
1153                         setting_password_main_draw_1line_password(ad, NULL);
1154                 break;
1155
1156         case SETTING_PW_TYPE_SIM_LOCK_ON:
1157                 setting_password_main_draw_2line_password(ad, NULL);
1158                 break;
1159         case SETTING_PW_TYPE_SET_PASSWORD:
1160                 if(ad->is_simple_password_on == 1)
1161                         setting_password_main_draw_simple_password(ad, 1);
1162                 else
1163                         setting_password_main_draw_2line_password(ad, NULL);
1164                 break;
1165
1166         case SETTING_PW_TYPE_CHANGE_PIN1:
1167         case SETTING_PW_TYPE_CHANGE_PIN2:
1168         case SETTING_PW_TYPE_PIN1_BLOCKED:
1169         case SETTING_PW_TYPE_PIN2_BLOCKED:
1170                 setting_password_main_draw_3line_password(ad, NULL);
1171                 break;
1172
1173         case SETTING_PW_TYPE_CHANGE_PASSWORD:
1174                 if(ad->is_simple_password_on == 1)
1175                         setting_password_main_draw_simple_password(ad, 3);
1176                 else
1177                         setting_password_main_draw_3line_password(ad, NULL);
1178                 break;
1179         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1180                 if(ad->is_simple_password_on == 1)      /* ON -> OFF */
1181                         setting_password_main_draw_simple_password(ad, 3);
1182                 else if(ad->is_simple_password_on == 0)                                                 /* OFF -> ON */
1183                         setting_password_main_draw_1line_password(ad, NULL);
1184                 break;
1185         default:
1186                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
1187                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
1188                 break;
1189         }
1190
1191         /** @todo this function always return 0, not verifying the function flow with the value */
1192         return 0;
1193 }
1194
1195 static void
1196 setting_password_main_entry_changed_cb(void *data, Evas_Object *obj,
1197                                        void *event_info)
1198 {
1199         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
1200         Setting_GenGroupItem_Data *list_item =
1201             (Setting_GenGroupItem_Data *) data;
1202         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
1203         const char *entry_str = elm_entry_entry_get(obj);
1204         list_item->sub_desc = (char *)g_strdup(entry_str);
1205         bool isFoundEmptyEntry = FALSE;
1206         Evas_Object *layout = elm_object_parent_widget_get(obj);
1207         elm_object_part_text_set(layout, "elm.guidetext", "");
1208
1209         do {
1210                 if (ad->ed_pw1) {
1211                         entry_str = ad->ed_pw1->sub_desc;
1212                         if (NULL == entry_str || '\0' == entry_str[0]) {
1213                                 isFoundEmptyEntry = TRUE;
1214                                 break;
1215                         }
1216                 }
1217                 if (ad->ed_pw2) {
1218                         entry_str = ad->ed_pw2->sub_desc;
1219                         if (NULL == entry_str || '\0' == entry_str[0]) {
1220                                 isFoundEmptyEntry = TRUE;
1221                                 break;
1222                         }
1223                 }
1224                 if (ad->ed_pw3) {
1225                         entry_str = ad->ed_pw3->sub_desc;
1226                         if (NULL == entry_str || '\0' == entry_str[0]) {
1227                                 isFoundEmptyEntry = TRUE;
1228                                 break;
1229                         }
1230                 }
1231
1232         } while (0);
1233
1234         bool disableFlag = isFoundEmptyEntry;
1235
1236         #if SUPPORT_BOTTOM_BTNS
1237         Evas_Object *done_btn = elm_object_item_part_content_get(ad->navi_it, "title_right_btn");
1238         if (disableFlag) {
1239                 if (!evas_object_pass_events_get(done_btn)) { /* it had not yet been disabled */
1240                         setting_disable_evas_object(done_btn);
1241                         setting_dim_evas_object(done_btn, TRUE);
1242                 }/* else already disabled */
1243         } else {
1244                 setting_enable_evas_object(done_btn);
1245                 setting_undo_dim_evas_object(done_btn, TRUE);
1246         }
1247         #else
1248         elm_object_item_disabled_set(elm_toolbar_last_item_get
1249                                          (ad->controllbar), disableFlag);
1250         #endif
1251
1252 }
1253
1254 static Eina_Bool __focus_on_idler(void *data)
1255 {
1256     /* error check */
1257         retv_if(data == NULL, FALSE);
1258
1259     SettingPasswordUG *ad = (SettingPasswordUG *) data;
1260
1261
1262         if((ad->is_simple_password_on == FALSE) && (ad->ed_pw1 != NULL))
1263     {
1264                 if (ad->ed_pw1->isFocusFlag || (ad->ed_pw1->eo_check != NULL))
1265         {
1266                         /* no matter how many edifileds, it only need focus on 1st editfiled */
1267                         elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
1268         }
1269     }
1270
1271         if((ad->is_simple_password_on == TRUE) && (ad->sp_entry1 != NULL))
1272     {
1273                 elm_object_focus_set(ad->sp_entry1, EINA_TRUE);
1274                 ad->sp_focused = ad->sp_entry1;
1275     }
1276
1277         return ECORE_CALLBACK_CANCEL;
1278 }
1279
1280
1281 static int setting_password_main_draw_next_simple_password(void *data, int title_index)
1282 {
1283         /* error check */
1284         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1285                  "[Setting > Password] Data parameter is NULL");
1286
1287         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1288
1289         setting_password_main_draw_simple_password(ad, title_index);
1290
1291         return SETTING_RETURN_SUCCESS;
1292 }
1293
1294 static int setting_password_main_draw_simple_password(void *data, int title_index)
1295 {
1296         /* error check */
1297         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1298                  "[Setting > Password] Data parameter is NULL");
1299
1300         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1301
1302         switch (ad->view_type) {
1303                 case SETTING_PW_TYPE_PHONE_LOCK:
1304                 case SETTING_PW_TYPE_SET_PASSWORD:
1305                 case SETTING_PW_TYPE_CHANGE_PASSWORD:
1306                 case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1307                 case SETTING_PW_TYPE_RESET:
1308                 case SETTING_PW_TYPE_LOCK_FOR_APP:
1309
1310                         ad->sp_title_index = title_index;
1311
1312                         if(ad->sp_item != NULL)
1313                         {
1314                                 elm_genlist_item_update(ad->sp_item);
1315                                 }
1316                         else
1317                         {
1318                                 elm_genlist_clear(ad->scroller);
1319                         ad->sp_item = elm_genlist_item_append(ad->scroller, &(ad->itc_sp_bg_1icon), ad, NULL,
1320                                                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1321                         }
1322
1323                         ecore_idler_add(__focus_on_idler, ad);
1324                 default:
1325                         break;
1326         }
1327         return 0;
1328 }
1329
1330 static int setting_password_main_draw_1line_password(void *data, void *cb)
1331 {
1332         /* error check */
1333         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1334                  "[Setting > Password] Data parameter is NULL");
1335
1336         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1337
1338         switch (ad->view_type) {
1339         case SETTING_PW_TYPE_POWER_ON_LOCK:
1340         case SETTING_PW_TYPE_PHONE_LOCK:
1341         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1342         case SETTING_PW_TYPE_RESET:
1343         case SETTING_PW_TYPE_CLEAR:
1344         case SETTING_PW_TYPE_LOCK_FOR_APP:
1345                 ad->ed_pw1 =
1346                     setting_create_Gendial_field_entry(ad->scroller,
1347                                                        &
1348                                                        (ad->itc_variable_height),
1349                                                        NULL, ad,
1350                                                        SWALLOW_Type_LAYOUT_ENTRY,
1351                                                        NULL, NULL, 0,
1352                                                        "IDS_COM_BODY_PASSWORD",
1353                                                        NULL,
1354                                                        setting_password_main_entry_changed_cb,
1355                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1356                                                        TRUE, TRUE,
1357                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1358                                                        0, NULL, NULL);
1359                 break;
1360         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1361                 ad->ed_pw1 =
1362                     setting_create_Gendial_field_entry(ad->scroller,
1363                                                        &
1364                                                        (ad->itc_variable_height),
1365                                                        NULL, ad,
1366                                                        SWALLOW_Type_LAYOUT_ENTRY,
1367                                                        NULL, NULL, 0,
1368                                                        "IDS_ST_BODY_SIM_PASSWORD",
1369                                                        NULL,
1370                                                        setting_password_main_entry_changed_cb,
1371                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1372                                                        TRUE, TRUE,
1373                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1374                                                        0, "0123456789", NULL);
1375                 break;
1376
1377         case SETTING_PW_TYPE_PIN_LOCK_ON:
1378         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1379                 ad->ed_pw1 =
1380                     setting_create_Gendial_field_entry(ad->scroller,
1381                                                        &
1382                                                        (ad->itc_variable_height),
1383                                                        NULL, ad,
1384                                                        SWALLOW_Type_LAYOUT_ENTRY,
1385                                                        NULL, NULL, 0,
1386                                                        "IDS_ST_BODY_PIN1", NULL,
1387                                                        setting_password_main_entry_changed_cb,
1388                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1389                                                        TRUE, TRUE,
1390                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1391                                                        0, "0123456789", NULL);
1392                 break;
1393
1394         case SETTING_PW_TYPE_FDN_MODE_ON:
1395         case SETTING_PW_TYPE_FDN_MODE_OFF:
1396                 ad->ed_pw1 =
1397                     setting_create_Gendial_field_entry(ad->scroller,
1398                                                        &
1399                                                        (ad->itc_variable_height),
1400                                                        NULL, ad,
1401                                                        SWALLOW_Type_LAYOUT_ENTRY,
1402                                                        NULL, NULL, 0,
1403                                                        "IDS_ST_BODY_PIN2", NULL,
1404                                                        setting_password_main_entry_changed_cb,
1405                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1406                                                        TRUE, TRUE,
1407                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1408                                                        0, "0123456789", NULL);
1409                 break;
1410
1411         default:
1412                 break;
1413         }
1414         ecore_idler_add(__focus_on_idler, ad);
1415         return 0;
1416 }
1417
1418 static int setting_password_main_clear_1line_password(void *data)
1419 {
1420         /* error check */
1421         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1422                  "[Setting > Password] Data parameter is NULL");
1423
1424         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1425         retv_if(NULL == ad->ed_pw1, -1);
1426
1427         ad->ed_pw1->sub_desc = NULL;
1428         ad->ed_pw1->isFocusFlag = FALSE;
1429
1430         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1431         return 0;
1432 }
1433
1434 static int setting_password_main_draw_2line_password(void *data, void *cb)
1435 {
1436         /* error check */
1437         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1438
1439         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1440
1441         switch (ad->view_type) {
1442         case SETTING_PW_TYPE_SET_PASSWORD:
1443         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1444                 ad->ed_pw1 =
1445                     setting_create_Gendial_field_entry(ad->scroller,
1446                                                        &
1447                                                        (ad->itc_variable_height),
1448                                                        NULL, ad,
1449                                                        SWALLOW_Type_LAYOUT_ENTRY,
1450                                                        NULL, NULL, 0,
1451                                                        "IDS_ST_BODY_NEW_PASSWORD",
1452                                                        NULL,
1453                                                        setting_password_main_entry_changed_cb,
1454                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1455                                                        TRUE, TRUE,
1456                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1457                                                        0, NULL, NULL);
1458
1459                 ad->ed_pw2 =
1460                     setting_create_Gendial_field_entry(ad->scroller,
1461                                                        &
1462                                                        (ad->itc_variable_height),
1463                                                        NULL, ad,
1464                                                        SWALLOW_Type_LAYOUT_ENTRY,
1465                                                        NULL, NULL, 0,
1466                                                        "IDS_ST_BODY_CONFIRM_PASSWORD",
1467                                                        NULL,
1468                                                        setting_password_main_entry_changed_cb,
1469                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1470                                                        TRUE, FALSE,
1471                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1472                                                        0, NULL, NULL);
1473                 break;
1474
1475         case SETTING_PW_TYPE_SIM_LOCK_ON:
1476                 ad->ed_pw1 =
1477                     setting_create_Gendial_field_entry(ad->scroller,
1478                                                        &
1479                                                        (ad->itc_variable_height),
1480                                                        NULL, ad,
1481                                                        SWALLOW_Type_LAYOUT_ENTRY,
1482                                                        NULL, NULL, 0,
1483                                                        "IDS_ST_BODY_SIM_PASSWORD",
1484                                                        NULL,
1485                                                        setting_password_main_entry_changed_cb,
1486                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1487                                                        TRUE, TRUE,
1488                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1489                                                        0, "0123456789", NULL);
1490
1491                 ad->ed_pw2 =
1492                     setting_create_Gendial_field_entry(ad->scroller,
1493                                                        &
1494                                                        (ad->itc_variable_height),
1495                                                        NULL, ad,
1496                                                        SWALLOW_Type_LAYOUT_ENTRY,
1497                                                        NULL, NULL, 0,
1498                                                        "IDS_ST_BODY_CONFIRM_SIM_PASSWORD",
1499                                                        NULL,
1500                                                        setting_password_main_entry_changed_cb,
1501                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1502                                                        TRUE, FALSE,
1503                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1504                                                        0, "0123456789", NULL);
1505                 break;
1506
1507         default:
1508                 break;
1509         }
1510         ecore_idler_add(__focus_on_idler, ad);
1511         return 0;
1512 }
1513
1514 static int setting_password_main_clear_2line_password(void *data)
1515 {
1516         /* error check */
1517         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1518                  "[Setting > Password] Data parameter is NULL");
1519
1520         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1521
1522         retv_if(NULL == ad->ed_pw1, -1);
1523         ad->ed_pw1->sub_desc = NULL;
1524         ad->ed_pw1->isFocusFlag = FALSE;
1525         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1526
1527         retv_if(NULL == ad->ed_pw2, -1);
1528         ad->ed_pw2->sub_desc = NULL;
1529         ad->ed_pw2->isFocusFlag = FALSE;
1530         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
1531         return 0;
1532 }
1533
1534 static int setting_password_main_draw_3line_password(void *data, void *cb)
1535 {
1536         /* error check */
1537         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1538                  "[Setting > Password] Data parameter is NULL");
1539
1540         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1541
1542         switch (ad->view_type) {
1543         case SETTING_PW_TYPE_CHANGE_PASSWORD:
1544                 ad->ed_pw1 =
1545                     setting_create_Gendial_field_entry(ad->scroller,
1546                                                        &(ad->itc_variable_height),
1547                                                        NULL, ad,
1548                                                        SWALLOW_Type_LAYOUT_ENTRY,
1549                                                        NULL, NULL, 0,
1550                                                        "IDS_ST_BODY_CURRENT_PASSWORD",
1551                                                        NULL,
1552                                                        setting_password_main_entry_changed_cb,
1553                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1554                                                        TRUE, TRUE,
1555                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1556                                                        0, NULL, NULL);
1557
1558                 ad->ed_pw2 =
1559                     setting_create_Gendial_field_entry(ad->scroller,
1560                                                        &(ad->itc_variable_height),
1561                                                        NULL, ad,
1562                                                        SWALLOW_Type_LAYOUT_ENTRY,
1563                                                        NULL, NULL, 0,
1564                                                        "IDS_ST_BODY_NEW_PASSWORD",
1565                                                        NULL,
1566                                                        setting_password_main_entry_changed_cb,
1567                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1568                                                        TRUE, FALSE,
1569                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1570                                                        0, NULL, NULL);
1571
1572                 ad->ed_pw3 =
1573                     setting_create_Gendial_field_entry(ad->scroller,
1574                                                        &(ad->itc_variable_height),
1575                                                        NULL, ad,
1576                                                        SWALLOW_Type_LAYOUT_ENTRY,
1577                                                        NULL, NULL, 0,
1578                                                        "IDS_ST_BODY_CONFIRM_PASSWORD",
1579                                                        NULL,
1580                                                        setting_password_main_entry_changed_cb,
1581                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1582                                                        TRUE, FALSE,
1583                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1584                                                        0, NULL, NULL);
1585                 break;
1586
1587         case SETTING_PW_TYPE_CHANGE_PIN1:
1588                 ad->ed_pw1 =
1589                     setting_create_Gendial_field_entry(ad->scroller,
1590                                                        &(ad->itc_variable_height),
1591                                                        NULL, ad,
1592                                                        SWALLOW_Type_LAYOUT_ENTRY,
1593                                                        NULL, NULL, 0,
1594                                                        "IDS_ST_BODY_CURRENT_PIN1",
1595                                                        NULL,
1596                                                        setting_password_main_entry_changed_cb,
1597                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1598                                                        TRUE, TRUE,
1599                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1600                                                        0, "0123456789", NULL);
1601
1602                 ad->ed_pw2 =
1603                     setting_create_Gendial_field_entry(ad->scroller,
1604                                                        &(ad->itc_variable_height),
1605                                                        NULL, ad,
1606                                                        SWALLOW_Type_LAYOUT_ENTRY,
1607                                                        NULL, NULL, 0,
1608                                                        "IDS_ST_BODY_NEW_PIN1",
1609                                                        NULL,
1610                                                        setting_password_main_entry_changed_cb,
1611                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1612                                                        TRUE, FALSE,
1613                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1614                                                        0, "0123456789", NULL);
1615
1616                 ad->ed_pw3 =
1617                     setting_create_Gendial_field_entry(ad->scroller,
1618                                                        &(ad->itc_variable_height),
1619                                                        NULL, ad,
1620                                                        SWALLOW_Type_LAYOUT_ENTRY,
1621                                                        NULL, NULL, 0,
1622                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN1",
1623                                                        NULL,
1624                                                        setting_password_main_entry_changed_cb,
1625                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1626                                                        TRUE, FALSE,
1627                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1628                                                        0, "0123456789", NULL);
1629                 break;
1630
1631         case SETTING_PW_TYPE_CHANGE_PIN2:
1632                 ad->ed_pw1 =
1633                     setting_create_Gendial_field_entry(ad->scroller,
1634                                                        &(ad->itc_variable_height),
1635                                                        NULL, ad,
1636                                                        SWALLOW_Type_LAYOUT_ENTRY,
1637                                                        NULL, NULL, 0,
1638                                                        "IDS_ST_BODY_CURRENT_PIN2",
1639                                                        NULL,
1640                                                        setting_password_main_entry_changed_cb,
1641                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1642                                                        TRUE, TRUE,
1643                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1644                                                        0, "0123456789", NULL);
1645
1646                 ad->ed_pw2 =
1647                     setting_create_Gendial_field_entry(ad->scroller,
1648                                                        &(ad->itc_variable_height),
1649                                                        NULL, ad,
1650                                                        SWALLOW_Type_LAYOUT_ENTRY,
1651                                                        NULL, NULL, 0,
1652                                                        "IDS_ST_BODY_NEW_PIN2",
1653                                                        NULL,
1654                                                        setting_password_main_entry_changed_cb,
1655                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1656                                                        TRUE, FALSE,
1657                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1658                                                        0, "0123456789", NULL);
1659
1660                 ad->ed_pw3 =
1661                     setting_create_Gendial_field_entry(ad->scroller,
1662                                                        &(ad->itc_variable_height),
1663                                                        NULL, ad,
1664                                                        SWALLOW_Type_LAYOUT_ENTRY,
1665                                                        NULL, NULL, 0,
1666                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN2",
1667                                                        NULL,
1668                                                        setting_password_main_entry_changed_cb,
1669                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1670                                                        TRUE, FALSE,
1671                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1672                                                        0, "0123456789", NULL);
1673                 break;
1674
1675         case SETTING_PW_TYPE_PIN1_BLOCKED:
1676                 ad->ed_pw1 =
1677                     setting_create_Gendial_field_entry(ad->scroller,
1678                                                        &(ad->itc_variable_height),
1679                                                        NULL, ad,
1680                                                        SWALLOW_Type_LAYOUT_ENTRY,
1681                                                        NULL, NULL, 0,
1682                                                        "IDS_ST_BODY_PUK1_CODE",
1683                                                        NULL,
1684                                                        setting_password_main_entry_changed_cb,
1685                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1686                                                        TRUE, TRUE,
1687                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1688                                                        0, "0123456789", NULL);
1689
1690                 ad->ed_pw2 =
1691                     setting_create_Gendial_field_entry(ad->scroller,
1692                                                        &(ad->itc_variable_height),
1693                                                        NULL, ad,
1694                                                        SWALLOW_Type_LAYOUT_ENTRY,
1695                                                        NULL, NULL, 0,
1696                                                        "IDS_ST_BODY_NEW_PIN1",
1697                                                        NULL,
1698                                                        setting_password_main_entry_changed_cb,
1699                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1700                                                        TRUE, FALSE,
1701                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1702                                                        0, "0123456789", NULL);
1703
1704                 ad->ed_pw3 =
1705                     setting_create_Gendial_field_entry(ad->scroller,
1706                                                        &(ad->itc_variable_height),
1707                                                        NULL, ad,
1708                                                        SWALLOW_Type_LAYOUT_ENTRY,
1709                                                        NULL, NULL, 0,
1710                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN1",
1711                                                        NULL,
1712                                                        setting_password_main_entry_changed_cb,
1713                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1714                                                        TRUE, FALSE,
1715                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1716                                                        0, "0123456789", NULL);
1717                 break;
1718
1719         case SETTING_PW_TYPE_PIN2_BLOCKED:
1720                 ad->ed_pw1 =
1721                     setting_create_Gendial_field_entry(ad->scroller,
1722                                                        &(ad->itc_variable_height),
1723                                                        NULL, ad,
1724                                                        SWALLOW_Type_LAYOUT_ENTRY,
1725                                                        NULL, NULL, 0,
1726                                                        "IDS_ST_BODY_PUK2", NULL,
1727                                                        setting_password_main_entry_changed_cb,
1728                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1729                                                        TRUE, TRUE,
1730                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1731                                                        0, "0123456789", NULL);
1732
1733                 ad->ed_pw2 =
1734                     setting_create_Gendial_field_entry(ad->scroller,
1735                                                        &(ad->itc_variable_height),
1736                                                        NULL, ad,
1737                                                        SWALLOW_Type_LAYOUT_ENTRY,
1738                                                        NULL, NULL, 0,
1739                                                        "IDS_ST_BODY_NEW_PIN2",
1740                                                        NULL,
1741                                                        setting_password_main_entry_changed_cb,
1742                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1743                                                        TRUE, FALSE,
1744                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1745                                                        0, "0123456789", NULL);
1746
1747                 ad->ed_pw3 =
1748                     setting_create_Gendial_field_entry(ad->scroller,
1749                                                        &(ad->itc_variable_height),
1750                                                        NULL, ad,
1751                                                        SWALLOW_Type_LAYOUT_ENTRY,
1752                                                        NULL, NULL, 0,
1753                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN2",
1754                                                        NULL,
1755                                                        setting_password_main_entry_changed_cb,
1756                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1757                                                        TRUE, FALSE,
1758                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1759                                                        0, "0123456789", NULL);
1760                 break;
1761
1762         default:
1763                 break;
1764         }
1765         ecore_idler_add(__focus_on_idler, ad);
1766         return 0;
1767 }
1768
1769 static int setting_password_main_clear_3line_password(void *data)
1770 {
1771         /* error check */
1772         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1773                  "[Setting > Password] Data parameter is NULL");
1774
1775         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1776
1777         retv_if(NULL == ad->ed_pw1, -1);
1778         ad->ed_pw1->sub_desc = NULL;
1779         ad->ed_pw1->isFocusFlag = FALSE;
1780         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1781
1782         retv_if(NULL == ad->ed_pw2, -1);
1783         ad->ed_pw2->sub_desc = NULL;
1784         ad->ed_pw2->isFocusFlag = FALSE;
1785         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
1786
1787         retv_if(NULL == ad->ed_pw3, -1);
1788         ad->ed_pw3->sub_desc = NULL;
1789         ad->ed_pw3->isFocusFlag = FALSE;
1790         elm_entry_entry_set(ad->ed_pw3->eo_check, "");
1791         return 0;
1792 }
1793
1794 static int setting_password_main_check_simple_password(const char *collection)
1795 {
1796         retv_if(collection == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1797
1798         int sp_len = safeStrLen(collection);
1799         int index = 0;
1800         char temp;
1801
1802         SETTING_TRACE_DEBUG("collection length is %d", sp_len);
1803
1804         if(sp_len != 4)
1805                 return SETTING_RETURN_FAIL;
1806
1807         /* check if digit. */
1808         for(index = 0; index < sp_len; index++)
1809         {
1810                 temp = (char)(collection[index]);
1811                 if((temp < '0') || ( temp > '9'))
1812                         return SETTING_RETURN_FAIL;
1813                 else
1814                         SETTING_TRACE_DEBUG("temp %c", temp);
1815         }
1816
1817         return SETTING_RETURN_SUCCESS;
1818 }
1819
1820 static int setting_password_main_check_1line_password(void *data)
1821 {
1822         /* error check */
1823         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1824
1825         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1826
1827         const char *entry_str = ad->ed_pw1->sub_desc;
1828         ad->focus_data = ad->ed_pw1;
1829
1830         /*  Empty Check */
1831         if (isEmptyStr(entry_str)) {
1832                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1833                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1834         }
1835
1836         /*  Length Check */
1837         int entry_str_len = safeStrLen(entry_str);
1838         switch (ad->view_type) {
1839         case SETTING_PW_TYPE_POWER_ON_LOCK:
1840         case SETTING_PW_TYPE_PHONE_LOCK:
1841         case SETTING_PW_TYPE_RESET:
1842         case SETTING_PW_TYPE_CLEAR:
1843         case SETTING_PW_TYPE_LOCK_FOR_APP:
1844                 {
1845                                 if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
1846                                 || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
1847                                 setting_password_main_warning_entry_added_byte_popup
1848                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
1849                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1850                         }
1851                 }
1852                 break;
1853         case SETTING_PW_TYPE_PIN_LOCK_ON:
1854         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1855         case SETTING_PW_TYPE_FDN_MODE_ON:
1856         case SETTING_PW_TYPE_FDN_MODE_OFF:
1857                 {
1858                         if (entry_str_len < SETTING_PW_UG_PIN_MIN_LENGTH
1859                             || entry_str_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
1860                                 setting_password_main_warning_entry_added_byte_popup
1861                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
1862                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1863                         }
1864                 }
1865                 break;
1866         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1867                 {
1868                         if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
1869                             || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH) {
1870                                 setting_password_main_warning_entry_added_byte_popup
1871                                         (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
1872                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1873                         }
1874                 }
1875         default:
1876                 break;
1877         }
1878         return SETTING_RETURN_SUCCESS;
1879 }
1880
1881 static int setting_password_main_check_2line_password(void *data)
1882 {
1883         /* error check */
1884         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1885
1886         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1887
1888         const char *entry_str1 = ad->ed_pw1->sub_desc;
1889         const char *entry_str2 = ad->ed_pw2->sub_desc;
1890         ad->focus_data = ad->ed_pw1;
1891
1892         /*  Empty Check */
1893         if (isEmptyStr(entry_str1)) {
1894                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1895                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1896         }
1897
1898         if (isEmptyStr(entry_str2)) {
1899                 ad->focus_data = ad->ed_pw2;
1900                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1901                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1902         }
1903
1904         /*  Length Check */
1905         int entry_str_len = safeStrLen(entry_str1);
1906         switch (ad->view_type) {
1907         case SETTING_PW_TYPE_SET_PASSWORD:
1908                 {
1909                                 if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
1910                                 || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
1911                                 setting_password_main_warning_entry_added_byte_popup
1912                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
1913                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1914                         }
1915                 }
1916                 break;
1917
1918         case SETTING_PW_TYPE_SIM_LOCK_ON:
1919                 {
1920                         if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
1921                             || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH) {
1922                                 setting_password_main_warning_entry_added_byte_popup
1923                                         (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
1924                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1925                         }
1926                 }
1927                 break;
1928         default:
1929                 break;
1930         }
1931
1932         /*  Match Check */
1933         if (0 != safeStrCmp(entry_str1, entry_str2)) {
1934                 setting_password_ug_display_desc(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
1935                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
1936         }
1937
1938         return SETTING_RETURN_SUCCESS;
1939 }
1940
1941 static void
1942 setting_password_main_warning_entry_added_byte_popup(SettingPasswordUG *ad,
1943                                                      int min, int max)
1944 {
1945         char str[MAX_SPECIALIZITION_LEN + 1] = { 0 };
1946
1947         snprintf(str, MAX_SPECIALIZITION_LEN, "%d~%d %s", min, max, _("characters required"));
1948
1949         setting_password_ug_display_desc(ad, str, FALSE);
1950 }
1951
1952 static int setting_password_main_check_3line_password(void *data)
1953 {
1954         /* error check */
1955         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1956
1957         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1958
1959         const char *entry_str1 = ad->ed_pw1->sub_desc;
1960         const char *entry_str2 = ad->ed_pw2->sub_desc;
1961         const char *entry_str3 = ad->ed_pw3->sub_desc;
1962         ad->focus_data = ad->ed_pw1;
1963
1964         /*  Empty Check */
1965         if (isEmptyStr(entry_str1)) {
1966                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1967                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1968         }
1969
1970         if (isEmptyStr(entry_str2)) {
1971                 ad->focus_data = ad->ed_pw2;
1972                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1973                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1974         }
1975
1976         if (isEmptyStr(entry_str3)) {
1977                 ad->focus_data = ad->ed_pw3;
1978                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1979                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1980         }
1981
1982         /*  Length Check */
1983         int entry_str1_len = safeStrLen(entry_str1);
1984         int entry_str2_len = safeStrLen(entry_str2);
1985         int entry_str3_len = safeStrLen(entry_str3);
1986         switch (ad->view_type) {
1987         case SETTING_PW_TYPE_CHANGE_PASSWORD:
1988         {
1989                         if (entry_str1_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
1990                                 || entry_str1_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
1991                         setting_password_main_warning_entry_added_byte_popup
1992                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
1993                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1994                 }
1995                         if (entry_str2_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
1996                                 || entry_str2_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
1997                         ad->focus_data = ad->ed_pw2;
1998                         setting_password_main_warning_entry_added_byte_popup
1999                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2000                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2001                 }
2002                         if (entry_str3_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
2003                                 || entry_str3_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
2004                         ad->focus_data = ad->ed_pw3;
2005                         setting_password_main_warning_entry_added_byte_popup
2006                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2007                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2008                 }
2009         }
2010                 break;
2011
2012         case SETTING_PW_TYPE_PIN1_BLOCKED:
2013         case SETTING_PW_TYPE_PIN2_BLOCKED:
2014         case SETTING_PW_TYPE_CHANGE_PIN1:
2015         case SETTING_PW_TYPE_CHANGE_PIN2:
2016                 {
2017                         if (entry_str1_len < SETTING_PW_UG_PIN_MIN_LENGTH
2018                             || entry_str1_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2019                                 setting_password_main_warning_entry_added_byte_popup
2020                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2021                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2022                         }
2023                         if (entry_str2_len < SETTING_PW_UG_PIN_MIN_LENGTH
2024                             || entry_str2_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2025                                 ad->focus_data = ad->ed_pw2;
2026                                 setting_password_main_warning_entry_added_byte_popup
2027                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2028                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2029                         }
2030                         if (entry_str3_len < SETTING_PW_UG_PIN_MIN_LENGTH
2031                             || entry_str3_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2032                                 ad->focus_data = ad->ed_pw3;
2033                                 setting_password_main_warning_entry_added_byte_popup
2034                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2035                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2036                         }
2037                 }
2038                 break;
2039         default:
2040                 break;
2041         }
2042
2043         /*  Match Check */
2044         if (0 != safeStrCmp(entry_str2, entry_str3)) {
2045                 ad->focus_data = ad->ed_pw2;
2046                 setting_password_ug_display_desc(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
2047                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
2048         }
2049
2050         return SETTING_RETURN_SUCCESS;
2051 }
2052
2053 static void
2054 setting_password_main_click_softkey_cancel_cb(void *data, Evas_Object *obj,
2055                                               void *event_info)
2056 {
2057         /* error check */
2058         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
2059
2060         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2061
2062         if(ad->sp_entry4)
2063         {
2064                 /*  add this below for removing IMF faster */
2065                 /*  need to discuss with IMF or Entry developer more */
2066                 elm_object_focus_set(ad->sp_entry4, EINA_FALSE);
2067                 /* end */
2068         }
2069
2070         /* for updating toggle button of simple password in security menu correctly. */
2071         if(ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
2072         {
2073                 bundle *b = bundle_create();
2074                 if(b == NULL)
2075                         return;
2076                 bundle_add(b, "result", ad->view_type_string);
2077                 ug_send_result(ad->ug, b);
2078                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
2079                 bundle_free(b);
2080         }
2081         /* Send destroy request */
2082         ug_destroy_me(ad->ug);
2083
2084 }
2085
2086 static void
2087 setting_password_main_click_softkey_done_cb(void *data, Evas_Object *obj,
2088                                             void *event_info)
2089 {
2090         /* error check */
2091         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
2092
2093         int err = 0;
2094         int ret = 0;
2095         char svalue[SHA256_DIGEST_LENGTH] = { 0, };
2096
2097         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
2098
2099         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2100         bundle *b = NULL;
2101
2102         SETTING_TRACE("ad->view_type:%d", ad->view_type);
2103
2104         switch (ad->view_type) {
2105                 case SETTING_PW_TYPE_RESET:
2106                 case SETTING_PW_TYPE_CLEAR:
2107                 case SETTING_PW_TYPE_POWER_ON_LOCK:
2108                 case SETTING_PW_TYPE_PHONE_LOCK:
2109                 case SETTING_PW_TYPE_LOCK_FOR_APP:
2110                         ret = setting_password_main_check_1line_password(ad);
2111
2112                         if (ret == SETTING_RETURN_SUCCESS) {
2113                                 const char *entry_str;
2114                                 entry_str = ad->ed_pw1->sub_desc;
2115
2116                                 ret = setting_password_check_password(entry_str);
2117                                 if(ret == SETTING_RETURN_SUCCESS)
2118                                 {
2119                                         int value;
2120                                         int err;
2121                                         int ret;
2122
2123                                         if (SETTING_PW_TYPE_PHONE_LOCK == ad->view_type) {
2124                                                 /*  Change Status */
2125                                                 setting_get_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK, &value, &err);
2126
2127                                                 if (value == 0)
2128                                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
2129                                                                                                                         SETTING_ON_OFF_BTN_ON, &err);
2130                                                 else
2131                                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
2132                                                                                                                 SETTING_ON_OFF_BTN_OFF, &err);
2133
2134                                                 /*  reset VCONF */
2135                                                 setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,
2136                                                                                         PHONE_LOCK_ATTEMPS_MAX, &err);
2137                                                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
2138                                         }
2139                                         /*  Correct Password. Send Bundle to caller for status change */
2140                                         b = bundle_create();
2141                                         if (!b)
2142                                                 return;
2143
2144                                         bundle_add(b, "result", ad->view_type_string);
2145                                         ug_send_result(ad->ug, b);
2146                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
2147                                         bundle_free(b);
2148                                         /* Send destroy request */
2149                                         ug_destroy_me(ad->ug);
2150                                 } else {
2151                                         /*  Incorrect Password. Display Popup.   */
2152                                         setting_password_main_clear_1line_password(ad);
2153                                         ad->focus_data = ad->ed_pw1;
2154                                         if (SETTING_PW_TYPE_PHONE_LOCK == ad->view_type) {
2155                                                 setting_password_ug_check_attemps_left(ad);
2156                                                 return;
2157                                         }
2158                                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2159                                         return;
2160                                 }
2161                         } else {
2162                                 setting_password_main_clear_1line_password(ad);
2163                                 return;
2164                         }
2165                         break;
2166                 case SETTING_PW_TYPE_SIMPLE_PASSWORD:
2167                         if(ad->is_simple_password_on == 0) /* OFF -> ON */
2168                         {
2169                                 SETTING_TRACE("case SIMPLE_PASSWORD OFF->ON");
2170                                 ret = setting_password_main_check_1line_password(ad);
2171
2172                                 if (ret == SETTING_RETURN_SUCCESS) {
2173                                         const char *entry_str = ad->ed_pw1->sub_desc;
2174
2175                                         ret = setting_password_check_password(entry_str);
2176                                         if(ret == SETTING_RETURN_SUCCESS)
2177                                         {
2178                                                 ad->cur_pwd = (char*)strdup(entry_str);
2179
2180                                                 elm_genlist_clear(ad->scroller);
2181                                                 /* disable "Done" button of navigation bar */
2182
2183                                                 if (ad->ly_main != NULL) {
2184                                                         evas_object_del(ad->ly_main);
2185                                                 }
2186                                                 __create_common_password_frame(ad);
2187                                                 setting_password_main_draw_simple_password(ad, 1);
2188                                         }
2189                                         else {
2190                                                 /* Incorrect Password. Display Popup. */
2191                                                 setting_password_main_clear_1line_password(ad);
2192                                                 ad->focus_data = ad->ed_pw1;
2193                                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2194
2195                                                 return;
2196                                         }
2197                                 } else {
2198                                         setting_password_main_clear_1line_password(ad);
2199                                 }
2200                         }
2201                         else if(ad->is_simple_password_on == 1) /* ON -> OFF */
2202                         {
2203                                 SETTING_TRACE("case SIMPLE_PASSWORD ON->OFF");
2204                                 ret = setting_password_main_check_2line_password(ad);
2205
2206                                 if (SETTING_RETURN_SUCCESS == ret) {
2207                                         const char *entry_str;
2208                                         entry_str = ad->ed_pw1->sub_desc;
2209
2210                                         if (isEmptyStr(entry_str)) {
2211                                                 ad->focus_data = ad->ed_pw1;
2212                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get return NULL ***%s",
2213                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2214                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2215                                                 return;
2216                                         }
2217
2218                                         ret = setting_password_set_password(ad->cur_pwd, entry_str, ad);
2219                                         FREE(ad->cur_pwd);
2220
2221                                         /* Modify Setting Password */
2222                                         if (SETTING_RETURN_FAIL != ret) {
2223                                                 /* Display popup */
2224                                                 /* set vconfkey OFF */
2225                                                 if(vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, 0) < 0)
2226                                                         vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, 0);
2227                                                 setting_password_ug_create_popup_notitle_nobtn(ad,
2228                                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
2229                                                 return;
2230                                         } else {
2231                                                 ad->focus_data = ad->ed_pw1;
2232                                                 /* Error Msg */
2233                                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
2234                                                                                 SETTING_FONT_RED, err, SETTING_FONT_BLACK);
2235                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2236                                                 return;
2237                                         }
2238                                 } else {
2239                                         setting_password_main_clear_2line_password(ad);
2240                                         return;
2241                                 }
2242                         }
2243                         break;
2244                 case SETTING_PW_TYPE_SET_PASSWORD:
2245                         {
2246                                 SETTING_TRACE("case SETTING_PW_TYPE_SET_PASSWORD");
2247                                 ret = setting_password_main_check_2line_password(ad);
2248
2249                                 if (SETTING_RETURN_SUCCESS == ret) {
2250                                         const char *entry_str;
2251                                         entry_str = ad->ed_pw1->sub_desc;
2252
2253                                         if (isEmptyStr(entry_str)) {
2254                                                 ad->focus_data = ad->ed_pw1;
2255                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get return NULL ***%s",
2256                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2257                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2258                                                 return;
2259                                         }
2260
2261                                         ret = setting_password_set_password(NULL, entry_str,ad);
2262
2263                                         /*  Modify Setting Password */
2264                                         if (SETTING_RETURN_FAIL != ret) {
2265                                                 if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PHONE_LOCK")) {
2266                                                         int err = 0;
2267                                                         int ret = 0;
2268
2269                                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
2270                                                                                                                 SETTING_ON_OFF_BTN_ON, &err);
2271                                                         retm_if(ret < 0, "[ERR] setting vconfkey failed.");
2272
2273                                                         b = bundle_create();
2274                                                         if (!b)
2275                                                                 return;
2276
2277                                                         bundle_add(b, "result", "SETTING_PW_TYPE_PHONE_LOCK");
2278                                                         ug_send_result(ad->ug, b);
2279                                                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_PHONE_LOCK");
2280                                                         bundle_free(b);
2281                                                         ug_destroy_me(ad->ug);
2282                                                 }
2283                                                 else if ( 0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_SIMPLE_PASSWORD")){
2284                                                         if (ad->ly_main != NULL) {
2285                                                                 evas_object_del(ad->ly_main);
2286                                                         }
2287
2288                                                         b = bundle_create();
2289                                                         if (!b)
2290                                                                 return;
2291
2292                                                         bundle_add(b, "result", "SETTING_PW_TYPE_SET_PASSWORD");
2293                                                         ug_send_result(ad->ug, b);
2294                                                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_SET_PASSWORD");
2295                                                         bundle_free(b);
2296                                                         /* Send destroy request */
2297                                                         ug_destroy_me(ad->ug);
2298
2299                                                         return;
2300                                                 }
2301                                                 else if ( 0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_LOCK_FOR_APP")){
2302                                                         if (ad->ly_main != NULL) {
2303                                                                 evas_object_del(ad->ly_main);
2304                                                         }
2305
2306                                                         b = bundle_create();
2307                                                         if (!b)
2308                                                                 return;
2309
2310                                                         bundle_add(b, "result", "SETTING_PW_TYPE_LOCK_FOR_APP");
2311                                                         ug_send_result(ad->ug, b);
2312                                                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_LOCK_FOR_APP");
2313                                                         bundle_free(b);
2314                                                         /* Send destroy request */
2315                                                         ug_destroy_me(ad->ug);
2316
2317                                                         return;
2318                                                 }
2319                                                 /*  Display popup */
2320                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
2321                                         } else {
2322                                                 ad->focus_data = ad->ed_pw1;
2323                                                 /*  Error Msg */
2324                                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
2325                                                                                 SETTING_FONT_RED, err, SETTING_FONT_BLACK);
2326                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2327                                                 return;
2328                                         }
2329                                 } else {
2330                                         setting_password_main_clear_2line_password(ad);
2331                                         return;
2332                                 }
2333                         }
2334                         break;
2335
2336                 case SETTING_PW_TYPE_CHANGE_PASSWORD:
2337                         {
2338                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PASSWORD");
2339                                 ret = setting_password_main_check_3line_password(ad);
2340
2341                                 if (SETTING_RETURN_SUCCESS == ret) {
2342                                         const char *entry_str;
2343 #if OLD
2344                                         entry_str = ad->ed_pw1->sub_desc;
2345                                         ret = setting_password_check_password(entry_str);
2346                                         if(ret != SETTING_RETURN_SUCCESS){
2347                                                 setting_password_main_clear_3line_password(ad);
2348                                                 ad->focus_data = ad->ed_pw1;
2349                                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2350                                                 return;
2351                                         }
2352 #endif
2353                                         entry_str = ad->ed_pw2->sub_desc;
2354
2355                                         if (isEmptyStr(entry_str)) {
2356                                                 ad->focus_data = ad->ed_pw2;
2357                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get(pw2) return NULL ***%s",
2358                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2359                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2360                                                 return;
2361                                         }
2362
2363                                         ret = setting_password_set_password(ad->ed_pw1->sub_desc, entry_str, ad);
2364
2365                                         /*  Modify Setting Password */
2366                                         if (SETTING_RETURN_FAIL != ret) {
2367                                                 /*  Display popup */
2368                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PASSWORD_CHANGED"), TRUE);
2369                                         } else {
2370                                                 ad->focus_data = ad->ed_pw2;
2371                                                 /*  Error Msg */
2372                                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
2373                                                                                 SETTING_FONT_RED, err, SETTING_FONT_BLACK);
2374                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2375                                                 return;
2376                                         }
2377
2378                                 } else {
2379                                         setting_password_main_clear_3line_password(ad);
2380                                         return;
2381                                 }
2382                         }
2383                         break;
2384
2385                 case SETTING_PW_TYPE_PIN_LOCK_ON:
2386                         {
2387                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_ON");
2388
2389                                 ret = setting_password_main_check_1line_password(ad);
2390                                 if (ret == SETTING_RETURN_SUCCESS) {
2391                                         TelSimSecPw_t sim_sec_data = { 0, };
2392                                         int tapi_ret = TAPI_API_SUCCESS;
2393                                         int ReqId;
2394                                         const char *entry_str;
2395
2396                                         entry_str = ad->ed_pw1->sub_desc;
2397                                         if (isEmptyStr(entry_str)) {
2398                                                 ad->focus_data = ad->ed_pw1;
2399                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
2400                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2401                                                 return;
2402                                         }
2403
2404                                         sim_sec_data.type = TAPI_SIM_PTYPE_PIN1;
2405                                         sim_sec_data.pw = (unsigned char *)entry_str;
2406                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2407
2408                                         tapi_ret = tel_enable_sim_security(&sim_sec_data, &ReqId);
2409                                         setting_password_main_clear_1line_password(ad);
2410
2411                                         if (TAPI_API_SUCCESS != tapi_ret) {
2412                                                 ad->focus_data = ad->ed_pw1;
2413                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_enable_sim_security err=%d ***%s",
2414                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2415                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2416                                                 return;
2417                                         } else {
2418                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2419                                                 SETTING_TRACE_DEBUG("%s*** [SUCCESS] tel_enable_sim_security err=%d ***%s",
2420                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2421                                         }
2422                                 } else {
2423                                         setting_password_main_clear_1line_password(ad);
2424                                 }
2425                         }
2426                         break;
2427                 case SETTING_PW_TYPE_PIN_LOCK_OFF:
2428                         {
2429                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_OFF");
2430
2431                                 ret = setting_password_main_check_1line_password(ad);
2432
2433                                 if (ret == SETTING_RETURN_SUCCESS) {
2434                                         TelSimSecPw_t sim_sec_data = { 0, };
2435                                         int tapi_ret = TAPI_API_SUCCESS;
2436                                         int ReqId;
2437                                         const char *entry_str;
2438
2439                                         entry_str = ad->ed_pw1->sub_desc;
2440                                         if (isEmptyStr(entry_str)) {
2441                                                 ad->focus_data = ad->ed_pw1;
2442                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
2443                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2444                                                 return;
2445                                         }
2446
2447                                         sim_sec_data.type = TAPI_SIM_PTYPE_PIN1;
2448                                         sim_sec_data.pw = (unsigned char *)entry_str;
2449                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2450
2451                                         tapi_ret = tel_disable_sim_security(&sim_sec_data, &ReqId);
2452                                         setting_password_main_clear_1line_password(ad);
2453
2454                                         if (TAPI_API_SUCCESS != tapi_ret) {
2455                                                 ad->focus_data = ad->ed_pw1;
2456                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_security err=%d ***%s",
2457                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2458                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2459                                                 return;
2460                                         } else {
2461                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status                                           */
2462                                         }
2463                                 } else {
2464                                         setting_password_main_clear_1line_password(ad);
2465                                 }
2466                         }
2467                         break;
2468
2469                 case SETTING_PW_TYPE_PIN1_BLOCKED:
2470                         {
2471                                 /*  PIN1 Status is "Blocked": User should input puk code and new pin1 code. */
2472                                 /*  If puk code is correct and success to modify pin1 code, display pin1 code change popup */
2473                                 /*  But, if this menu is "Pin Lock", pinlock status will not be changed. */
2474                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN1_BLOCKED");
2475                                 ret = setting_password_main_check_3line_password(ad);
2476
2477                                 if (ret == SETTING_RETURN_SUCCESS) {
2478                                         TelSimSecPw_t puk1_data = { 0, };
2479                                         TelSimSecPw_t pin1_data = { 0, };
2480                                         int tapi_ret = TAPI_API_SUCCESS;
2481                                         int ReqId;
2482                                         const char *puk;
2483                                         const char *new_pin1;
2484
2485                                         puk = ad->ed_pw1->sub_desc;
2486                                         new_pin1 = ad->ed_pw2->sub_desc;
2487                                         if (isEmptyStr(puk)) {
2488                                                 ad->focus_data = ad->ed_pw1;
2489                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2490                                                 return;
2491                                         }
2492
2493                                         if (isEmptyStr(new_pin1)) {
2494                                                 ad->focus_data = ad->ed_pw2;
2495                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2496                                                 return;
2497                                         }
2498
2499                                         puk1_data.type = TAPI_SIM_PTYPE_PUK1;
2500                                         puk1_data.pw = (unsigned char *)puk;
2501                                         puk1_data.pw_len = safeStrLen(puk);
2502
2503                                         pin1_data.type = TAPI_SIM_PTYPE_PIN1;
2504                                         pin1_data.pw = (unsigned char *)new_pin1;
2505                                         pin1_data.pw_len = safeStrLen(new_pin1);
2506
2507                                         tapi_ret = tel_verify_sim_puks(&puk1_data, &pin1_data, &ReqId);
2508                                         setting_password_main_clear_3line_password(ad);
2509
2510                                         if (TAPI_API_SUCCESS != tapi_ret) {
2511                                                 ad->focus_data = ad->ed_pw1;
2512                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
2513                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2514                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2515                                                 return;
2516                                         } else {
2517                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2518
2519                                         }
2520                                 } else {
2521                                         setting_password_main_clear_3line_password(ad);
2522                                 }
2523                         }
2524                         break;
2525                 case SETTING_PW_TYPE_PIN2_BLOCKED:
2526                         {
2527                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN2_BLOCKED");
2528                                 ret = setting_password_main_check_3line_password(ad);
2529
2530                                 if (ret == SETTING_RETURN_SUCCESS) {
2531                                         TelSimSecPw_t puk2_data = { 0, };
2532                                         TelSimSecPw_t pin2_data = { 0, };
2533                                         int tapi_ret = TAPI_API_SUCCESS;
2534                                         int ReqId;
2535                                         const char *puk;
2536                                         const char *new_pin2;
2537
2538                                         puk = ad->ed_pw1->sub_desc;
2539                                         new_pin2 = ad->ed_pw2->sub_desc;
2540                                         if (isEmptyStr(puk)) {
2541                                                 ad->focus_data = ad->ed_pw1;
2542                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2543                                                 return;
2544                                         }
2545
2546                                         if (isEmptyStr(new_pin2)) {
2547                                                 ad->focus_data = ad->ed_pw2;
2548                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2549                                                 return;
2550                                         }
2551
2552                                         puk2_data.type = TAPI_SIM_PTYPE_PUK2;
2553                                         puk2_data.pw = (unsigned char *)puk;
2554                                         puk2_data.pw_len = safeStrLen(puk);
2555
2556                                         pin2_data.type = TAPI_SIM_PTYPE_PIN2;
2557                                         pin2_data.pw = (unsigned char *)new_pin2;
2558                                         pin2_data.pw_len = safeStrLen(new_pin2);
2559
2560                                         tapi_ret = tel_verify_sim_puks(&puk2_data, &pin2_data, &ReqId);
2561                                         setting_password_main_clear_3line_password(ad);
2562
2563                                         if (TAPI_API_SUCCESS != tapi_ret) {
2564                                                 ad->focus_data = ad->ed_pw1;
2565                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
2566                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2567                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2568                                                 return;
2569                                         } else {
2570                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2571
2572                                         }
2573                                 } else {
2574                                         setting_password_main_clear_3line_password(ad);
2575                                 }
2576                         }
2577                         break;
2578                 case SETTING_PW_TYPE_CHANGE_PIN1:
2579                         {
2580                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN1");
2581
2582                                 ret = setting_password_main_check_3line_password(ad);
2583                                 if (ret == SETTING_RETURN_SUCCESS) {
2584                                         const char *old_pw;
2585                                         const char *new_pw;
2586                                         TelSimSecPw_t sim_old_sec_data = { 0, };
2587                                         TelSimSecPw_t sim_new_sec_data = { 0, };
2588                                         int tapi_ret = TAPI_API_SUCCESS;
2589                                         int ReqId;
2590
2591                                         old_pw = ad->ed_pw1->sub_desc;
2592                                         new_pw = ad->ed_pw2->sub_desc;
2593                                         if (isEmptyStr(old_pw)) {
2594                                                 ad->focus_data = ad->ed_pw1;
2595                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2596                                                 return;
2597                                         }
2598
2599                                         if (isEmptyStr(new_pw)) {
2600                                                 ad->focus_data = ad->ed_pw2;
2601                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2602                                                 return;
2603                                         }
2604
2605                                         sim_old_sec_data.type = sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN1;
2606                                         sim_old_sec_data.pw = (unsigned char *)old_pw;
2607                                         sim_old_sec_data.pw_len = safeStrLen(old_pw);
2608                                         sim_new_sec_data.pw = (unsigned char *)new_pw;
2609                                         sim_new_sec_data.pw_len = safeStrLen(new_pw);
2610
2611                                         tapi_ret = tel_change_sim_pins(&sim_old_sec_data, &sim_new_sec_data, &ReqId);
2612                                         setting_password_main_clear_3line_password(ad);
2613
2614                                         if (TAPI_API_SUCCESS != tapi_ret) {
2615                                                 ad->focus_data = ad->ed_pw1;
2616                                                 SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
2617                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2618                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2619                                                 return;
2620                                         } else {
2621                                                 /*  Success popup and send message to caller */
2622                                                 /* setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PIN1_CHANGED")); */
2623                                         }
2624                                 } else {
2625                                         setting_password_main_clear_3line_password(ad);
2626                                         return;
2627                                 }
2628                         }
2629                         break;
2630                 case SETTING_PW_TYPE_CHANGE_PIN2:
2631                         {
2632                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN2");
2633                                 ret = setting_password_main_check_3line_password(ad);
2634                                 if (ret == SETTING_RETURN_SUCCESS) {
2635                                         const char *old_pw;
2636                                         const char *new_pw;
2637                                         TelSimSecPw_t sim_old_sec_data = { 0, };
2638                                         TelSimSecPw_t sim_new_sec_data = { 0, };
2639                                         int tapi_ret = TAPI_API_SUCCESS;
2640                                         int ReqId;
2641
2642                                         old_pw = ad->ed_pw1->sub_desc;
2643                                         new_pw = ad->ed_pw2->sub_desc;
2644                                         if (isEmptyStr(old_pw)) {
2645                                                 ad->focus_data = ad->ed_pw1;
2646                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2647                                                 return;
2648                                         }
2649
2650                                         if (isEmptyStr(new_pw)) {
2651                                                 ad->focus_data = ad->ed_pw2;
2652                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2653                                                 return;
2654                                         }
2655
2656                                         sim_old_sec_data.type = sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN2;
2657                                         sim_old_sec_data.pw = (unsigned char *)old_pw;
2658                                         sim_old_sec_data.pw_len = safeStrLen(old_pw);
2659                                         sim_new_sec_data.pw = (unsigned char *)new_pw;
2660                                         sim_new_sec_data.pw_len = safeStrLen(new_pw);
2661
2662                                         tapi_ret = tel_change_sim_pins(&sim_old_sec_data, &sim_new_sec_data, &ReqId);
2663                                         setting_password_main_clear_3line_password(ad);
2664
2665                                         if (TAPI_API_SUCCESS != tapi_ret) {
2666                                                 ad->focus_data = ad->ed_pw1;
2667                                                 SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
2668                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2669                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2670                                                 return;
2671                                         } else {
2672                                                 /*  Success popup and send message to caller */
2673                                                 /* setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PIN2_CHANGED")); */
2674                                         }
2675                                 } else {
2676                                         setting_password_main_clear_3line_password(ad);
2677                                         return;
2678                                 }
2679                         }
2680                         break;
2681
2682                 case SETTING_PW_TYPE_SIM_LOCK_ON:
2683                         {
2684                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_ON");
2685
2686                                 ret = setting_password_main_check_2line_password(ad);
2687
2688                                 if (ret == SETTING_RETURN_SUCCESS) {
2689                                         TelSimSecPw_t sim_sec_data = { 0, };
2690                                         int tapi_ret = TAPI_API_SUCCESS;
2691                                         int ReqId;
2692                                         const char *entry_str;
2693                                         entry_str = ad->ed_pw1->sub_desc;
2694                                         if (isEmptyStr(entry_str)) {
2695                                                 ad->focus_data = ad->ed_pw1;
2696                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2697                                                 return;
2698                                         }
2699
2700                                         sim_sec_data.type = TAPI_SIM_PTYPE_SIM;
2701                                         sim_sec_data.pw = (unsigned char *)entry_str;
2702                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2703
2704                                         tapi_ret = tel_enable_sim_security(&sim_sec_data, &ReqId);
2705                                         setting_password_main_clear_2line_password(ad);
2706
2707                                         SETTING_TRACE("SIM Lock password : %s\n", (char *)(sim_sec_data.pw));
2708                                         if (TAPI_API_SUCCESS != tapi_ret) {
2709                                                 ad->focus_data = ad->ed_pw1;
2710                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_enable_sim_security err=%d ***%s",
2711                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2712                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2713                                                 return;
2714                                         } else {
2715                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2716
2717                                         }
2718                                 } else {
2719                                         setting_password_main_clear_2line_password(ad);
2720                                 }
2721                         }
2722                         break;
2723
2724                 case SETTING_PW_TYPE_SIM_LOCK_OFF:
2725                         {
2726                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_OFF");
2727
2728                                 ret = setting_password_main_check_1line_password(ad);
2729                                 if (ret == SETTING_RETURN_SUCCESS) {
2730                                         TelSimSecPw_t sim_sec_data = { 0, };
2731                                         int tapi_ret = TAPI_API_SUCCESS;
2732                                         int ReqId;
2733                                         const char *entry_str;
2734
2735                                         entry_str = ad->ed_pw1->sub_desc;
2736                                         if (isEmptyStr(entry_str)) {
2737                                                 ad->focus_data = ad->ed_pw1;
2738                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2739                                                 return;
2740                                         }
2741
2742                                         sim_sec_data.type = TAPI_SIM_PTYPE_SIM;
2743                                         sim_sec_data.pw = (unsigned char *)entry_str;
2744                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2745
2746                                         tapi_ret = tel_disable_sim_security(&sim_sec_data, &ReqId);
2747                                         setting_password_main_clear_1line_password(ad);
2748
2749                                         if (TAPI_API_SUCCESS != tapi_ret) {
2750                                                 ad->focus_data = ad->ed_pw1;
2751                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_security err=%d ***%s",
2752                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2753                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2754                                                 return;
2755                                         } else {
2756                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2757
2758                                         }
2759                                 } else {
2760                                         setting_password_main_clear_1line_password(ad);
2761                                 }
2762                         }
2763                         break;
2764
2765                 default:
2766                         /* Send destroy request */
2767                         ug_destroy_me(ad->ug);
2768                         break;
2769         }
2770 }