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

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <setting-password.h>
  23 #include <setting-password-main.h>
  24 #include <setting-common-data-slp-setting.h>
  25 #include <openssl/sha.h>
  26 #include <setting-debug.h>
  27
  28 #ifdef SUPPORT_MDM
  29 #include <sys/types.h>
  30 #include <regex.h>
  31 #endif
  32
  33 static int setting_password_main_create(void *cb);
  34 static int setting_password_main_destroy(void *cb);
  35 static int setting_password_main_update(void *cb);
  36 static int setting_password_main_cleanup(void *cb);
  37
  38 setting_view setting_view_password_main = {
  39         .create = setting_password_main_create,
  40         .destroy = setting_password_main_destroy,
  41         .update = setting_password_main_update,
  42         .cleanup = setting_password_main_cleanup,
  43 };
  44
  45 const char *sp_titles[5] = { "IDS_ST_BODY_ENTER_PASSWORD",
  46                 "IDS_ST_BODY_ENTER_NEW_PASSWORD",
  47                 "IDS_ST_BODY_ENTER_PASSWORD_AGAIN",
  48                 "IDS_ST_BODY_ENTER_CURRENT_PASSWORD",
  49                 NULL
  50 };
  51 #define SETTING_SP_TITLE_INDEX_START 0
  52 #define SETTING_SP_TITLE_INDEX_MAX 3
  53
  54 #define ENTRY_CALLBACK_REPEAT_MAX 3
  55 #define SETTING_COMPARE_PW_FAIL -2
  56
  57 static void _sp_changed_cb1(void *data, Evas_Object *obj, void *event_info);
  58 static void _sp_changed_cb2(void *data, Evas_Object *obj, void *event_info);
  59 static void _sp_changed_cb3(void *data, Evas_Object *obj, void *event_info);
  60 static void _sp_changed_cb4(void *data, Evas_Object *obj, void *event_info);
  61
  62 #ifdef SUPPORT_MDM
  63 int _count_string(const char *str, int *cnt_letter, int *cnt_digit, int *cnt_sym);
  64 #endif
  65
  66 /* ***************************************************
  67  *
  68  *basic func
  69  *
  70  ***************************************************/
  71 static void
  72 __password_main_gl_mouse_up(void *data, Evas *e, Evas_Object *obj,
  73                             void *event)
  74 {
  75         ret_if(!data);
  76         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  77
  78         if (ad->ed_pw1) {
  79                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  80         }
  81         if (ad->ed_pw2) {
  82                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  83         }
  84         if (ad->ed_pw3) {
  85                 setting_hide_input_pannel_cb(ad->ed_pw1->eo_check);
  86         }
  87
  88 }
  89
  90 static char *setting_password_main_get_title_str(void *data)
  91 {
  92         retvm_if(data == NULL, NULL,
  93                  "[Setting > Password] Data parameter is NULL");
  94         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  95
  96         switch (ad->view_type) {
  97         case SETTING_PW_TYPE_PASSWORD:
  98         case SETTING_PW_TYPE_SET_PASSWORD:
  99         case SETTING_PW_TYPE_CHANGE_PASSWORD:
 100         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
 101         case SETTING_PW_TYPE_SET_SIMPLE_PASSWORD:
 102         case SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD:
 103 #ifdef SUPPORT_MDM
 104         case SETTING_PW_TYPE_MDM_NEW_POLICY:
 105         case SETTING_PW_TYPE_MDM_CHANGE_PASSWORD:
 106         case SETTING_PW_TYPE_MDM_TO_SIMPLE:
 107 #endif
 108                 return _("IDS_COM_BODY_AUTH_PASSWORD");
 109                 break;
 110
 111         case SETTING_PW_TYPE_SIM_LOCK_ON:
 112         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 113                 return _("IDS_COM_BODY_AUTH_PASSWORD");
 114                 break;
 115         case SETTING_PW_TYPE_PIN_LOCK_ON:
 116         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 117                 return _("IDS_ST_BODY_PIN1");
 118                 break;
 119         case SETTING_PW_TYPE_CHANGE_PIN1:
 120                 return _("IDS_ST_BODY_CHANGE_PIN1");
 121                 break;
 122
 123         case SETTING_PW_TYPE_CHANGE_PIN2:
 124                 return _("IDS_ST_BODY_CHANGE_PIN2");
 125                 break;
 126
 127         case SETTING_PW_TYPE_PIN1_BLOCKED:
 128                 return _("IDS_ST_BODY_PUK1_CODE");
 129                 break;
 130         case SETTING_PW_TYPE_PIN2_BLOCKED:
 131
 132                 return _("IDS_ST_BODY_PUK2");
 133                 break;
 134         default:
 135                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
 136                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 137                 break;
 138         }
 139         return NULL;
 140
 141 }
 142
 143 static void
 144 _sp_back_key_up(void *data, Evas *e, Evas_Object *obj, void *event)
 145 {
 146         retm_if(data == NULL || event == NULL, "[Setting > Password] Data parameter is NULL");
 147
 148         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 149
 150         ret_if(ad->sp_focused == NULL || ad->sp_entry1 == NULL || ad->sp_entry2 == NULL
 151                         || ad->sp_entry3 == NULL || ad->sp_entry4 == NULL);
 152
 153         Evas_Object *cur_entry = NULL;
 154         Evas_Object *move_to = NULL;
 155
 156         Evas_Event_Key_Up *ev = (Evas_Event_Key_Up*)event;
 157
 158         cur_entry = ad->sp_focused;
 159
 160         if(cur_entry == ad->sp_entry1)
 161         {
 162                 /* nothing to move. */
 163                 return;
 164         }
 165         else if(cur_entry == ad->sp_entry2)
 166         {
 167                 move_to = ad->sp_entry1;
 168         }
 169         else if(cur_entry == ad->sp_entry3)
 170         {
 171                 move_to = ad->sp_entry2;
 172         }
 173         else if(cur_entry == ad->sp_entry4)
 174         {
 175                 move_to = ad->sp_entry3;
 176         }
 177         else
 178         {
 179                 return;
 180         }
 181
 182         if(strcmp(ev->keyname, "BackSpace") == 0)
 183         {
 184                 SETTING_TRACE_DEBUG("BackSpace Key Up");
 185                 elm_object_focus_set(move_to, EINA_TRUE);
 186                 elm_entry_entry_set(move_to, "<font_size=52 align=center>");
 187                 elm_entry_cursor_end_set(move_to);
 188                 ad->sp_focused = move_to;
 189         }
 190 }
 191
 192 Elm_Object_Item* __create_navibar(void *data, Evas_Object *content, Evas_Object *navibar, setting_pw_navibar_style_t style)
 193 {
 194         SETTING_TRACE_BEGIN;
 195         retv_if(data == NULL || content == NULL || navibar == NULL, NULL);
 196
 197         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 198
 199         Elm_Object_Item *navi_item = NULL;
 200         Evas_Object *done_btn = NULL;
 201
 202         switch(style)
 203         {
 204                 case SETTING_PW_NAVIBAR_WITH_LEFT_BTN :
 205                         SETTING_TRACE_DEBUG("with left btn");
 206                         navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 207                                                                         NULL, _("IDS_COM_SK_CANCEL"), NULL,
 208                                                                         NULL,
 209                                                                         setting_password_main_click_softkey_cancel_cb,
 210                                                                         NULL, ad, content, navibar);
 211                         break;
 212                 case SETTING_PW_NAVIBAR_WITH_RIGHT_BTN :
 213                         SETTING_TRACE_DEBUG("with right btn");
 214                         navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 215                                                                         _("IDS_COM_SK_DONE"), NULL, NULL,
 216                                                                         setting_password_main_click_softkey_done_cb, NULL,
 217                                                                         NULL, ad, content, navibar);
 218                         break;
 219                 case SETTING_PW_NAVIBAR_WITH_BOTH_BTN:
 220                         SETTING_TRACE_DEBUG("with both btn");
 221                         navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 222                                                                         _("IDS_COM_SK_DONE"), _("IDS_COM_SK_CANCEL"), NULL,
 223                                                                         setting_password_main_click_softkey_done_cb,
 224                                                                         setting_password_main_click_softkey_cancel_cb,
 225                                                                         NULL, ad, content, navibar);
 226                         break;
 227                 case SETTING_PW_NAVIBAR_WITH_NO_BTN:
 228                         SETTING_TRACE_DEBUG("with no btn");
 229                         navi_item = setting_create_navi_bar_top_buttons(setting_password_main_get_title_str(ad),
 230                                                                         NULL, NULL, NULL,
 231                                                                         NULL,
 232                                                                         NULL,
 233                                                                         NULL, ad, content, navibar);
 234                 default:
 235                         break;
 236         }
 237         retv_if(!navi_item, NULL);
 238
 239         done_btn = elm_object_item_part_content_get(navi_item, NAVI_BTN_STYLE_LEFT);
 240         if(done_btn != NULL)
 241         {
 242                 setting_disable_evas_object(done_btn);
 243                 setting_dim_evas_object(done_btn, TRUE);
 244         }
 245         return navi_item;
 246 }
 247
 248 static int __create_common_password_frame(void *data)
 249 {
 250         SETTING_TRACE_BEGIN;
 251         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 252
 253         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 254         Evas_Object *navi_bar = NULL;
 255         static int count = 0;
 256
 257         count++;
 258         /* CONTENT */
 259         if(ad->scroller != NULL)
 260         {
 261                 evas_object_del(ad->scroller);
 262         }
 263
 264         Evas_Object *pw_list = elm_genlist_add(ad->win_main_layout);
 265         elm_object_style_set(pw_list, "dialogue");
 266         if(pw_list == NULL)
 267                 return SETTING_RETURN_FAIL;
 268
 269         elm_genlist_clear(pw_list);     /* first to clear list */
 270         elm_genlist_mode_set(pw_list, ELM_LIST_COMPRESS);
 271
 272
 273 #if SUPPORT_BOTTOM_BTNS
 274         ad->ly_main = setting_create_win_layout(ad->win_main_layout, ad->win_get);
 275         retv_if(!ad->ly_main, SETTING_RETURN_FAIL);
 276
 277         navi_bar = setting_create_navi_bar(ad->ly_main);
 278         retv_if(!navi_bar, SETTING_RETURN_FAIL);
 279
 280 #ifdef SUPPORT_MDM
 281         if((ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
 282                 || (ad->view_type == SETTING_PW_TYPE_MDM_CHANGE_PASSWORD))
 283         {
 284                 ad->navi_it = __create_navibar(ad, pw_list, navi_bar, SETTING_PW_NAVIBAR_WITH_BOTH_BTN);
 285         }
 286         else if(ad->view_type == SETTING_PW_TYPE_MDM_TO_SIMPLE)
 287         {
 288                 ad->navi_it = __create_navibar(ad, pw_list, navi_bar, SETTING_PW_NAVIBAR_WITH_LEFT_BTN);
 289         }
 290         else
 291         {
 292 #endif
 293         if(     (ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
 294                         || (ad->view_type == SETTING_PW_TYPE_SET_SIMPLE_PASSWORD)
 295                         || (ad->view_type == SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD))
 296         {
 297                 ad->navi_it = __create_navibar(ad, pw_list, navi_bar, SETTING_PW_NAVIBAR_WITH_LEFT_BTN);
 298         }
 299         else
 300         {
 301                 ad->navi_it = __create_navibar(ad, pw_list, navi_bar, SETTING_PW_NAVIBAR_WITH_BOTH_BTN);
 302         }
 303 #ifdef SUPPORT_MDM
 304         }
 305 #endif
 306
 307         retv_if(!ad->navi_it, SETTING_RETURN_FAIL);
 308 #else
 309         ad->ly_main =
 310             setting_create_layout_navi_bar(ad->win_main_layout, ad->win_get,
 311                                            setting_password_main_get_title_str
 312                                            (ad), _("IDS_COM_SK_CANCEL"),
 313                                            _("IDS_COM_SK_DONE"), NULL,
 314                                            setting_password_main_click_softkey_cancel_cb,
 315                                            setting_password_main_click_softkey_done_cb,
 316                                            NULL, ad, pw_list /* contents */ ,
 317                                            &navi_bar, &(ad->controllbar));
 318         elm_object_item_disabled_set(elm_toolbar_last_item_get(ad->controllbar), EINA_TRUE);
 319
 320         if(ad->ly_main == NULL)
 321                 return SETTING_RETURN_FAIL;
 322 #endif
 323
 324         evas_object_event_callback_add(pw_list, EVAS_CALLBACK_MOUSE_UP,
 325                                        __password_main_gl_mouse_up, ad);
 326
 327         Elm_Object_Item *item = elm_genlist_item_append(pw_list,
 328                                                                 &(ad->itc_seperator), NULL, NULL,
 329                                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 330         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 331
 332         ad->scroller = pw_list;
 333
 334         return SETTING_RETURN_SUCCESS;
 335 }
 336
 337 static void _copy_chars_from_sp_entries(void *data, char *collection)
 338 {
 339         ret_if(data == NULL || collection == NULL);
 340
 341         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 342
 343         if(ad->sp_entry1 == NULL || ad->sp_entry2 == NULL ||
 344                 ad->sp_entry3 == NULL || ad->sp_entry4 == NULL)
 345                 return;
 346
 347         strncpy(&collection[0], elm_entry_entry_get(ad->sp_entry1), 1);
 348         strncpy(&collection[1], elm_entry_entry_get(ad->sp_entry2), 1);
 349         strncpy(&collection[2], elm_entry_entry_get(ad->sp_entry3), 1);
 350         strncpy(&collection[3], elm_entry_entry_get(ad->sp_entry4), 1);
 351 }
 352
 353 static int _handle_step1(void *data, char *collection)
 354 {
 355         retv_if(data == NULL, SETTING_RETURN_FAIL);
 356
 357         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 358         int ret = 0;
 359         int err = 0;
 360
 361         char svalue[SHA256_DIGEST_LENGTH];
 362         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 363
 364         _copy_chars_from_sp_entries(ad, collection);
 365
 366         ret = setting_password_main_check_simple_password(collection);
 367         if(ret < 0)
 368         {
 369                 setting_password_main_draw_simple_password(ad, 3);
 370                 return SETTING_RETURN_FAIL;
 371         }
 372
 373         ret = setting_password_check_password(collection, NULL, NULL);
 374         if(ret != SETTING_RETURN_SUCCESS)
 375         {
 376                 setting_password_main_draw_simple_password(ad, 3);
 377                 return SETTING_COMPARE_PW_FAIL;
 378         }
 379
 380         int value = 0;
 381
 382         if ( 0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_SIMPLE_PASSWORD"))
 383         {
 384                 setting_get_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK, &value, &err);
 385                 SETTING_TRACE_DEBUG("get VCONF POWER_ON_LOCK : %d", value);
 386
 387                 if (value == 0)
 388                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 389                                                      SETTING_ON_OFF_BTN_ON, &err);
 390                 else
 391                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 392                                                      SETTING_ON_OFF_BTN_OFF, &err);
 393
 394                 /* reset VCONF */
 395                 setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,
 396                                      PHONE_LOCK_ATTEMPS_MAX, &err);
 397                 setting_retvm_if(err == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
 398
 399                 /* Correct Password. Send Bundle to caller for status change */
 400         }
 401
 402         service_h svc;
 403         if (service_create(&svc))
 404         {
 405                 setting_password_main_draw_simple_password(ad, 3);
 406                 return SETTING_RETURN_FAIL;
 407         }
 408
 409         service_add_extra_data(svc, "result", ad->view_type_string);
 410
 411         if(0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_ENTER_LOCK_TYPE"))
 412                 service_add_extra_data(svc, "current", collection);
 413
 414         /* reset static variables */
 415         memset(collection, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 416
 417         ug_send_result(ad->ug, svc);
 418         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 419         service_destroy(svc);
 420         /* Send destroy request */
 421         ug_destroy_me(ad->ug);
 422
 423         return SETTING_RETURN_SUCCESS;
 424 }
 425 #if DISABLED_CODE
 426 static int _handle_step_sp(void *data, int *step, char *collection1, char *collection2)
 427 {
 428         retv_if(data == NULL, SETTING_RETURN_FAIL);
 429
 430         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 431         int ret = 0;
 432
 433         char svalue[SHA256_DIGEST_LENGTH];
 434         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 435
 436         if(ad->is_simple_password_on == 1)
 437         {
 438                 SETTING_TRACE_DEBUG("case ON->OFF");
 439                 _copy_chars_from_sp_entries(ad, collection1);
 440
 441                 ret = setting_password_main_check_simple_password(collection1);
 442                 if(ret < 0)
 443                 {
 444                         setting_password_main_draw_simple_password(ad, 3);
 445                         return SETTING_RETURN_FAIL;
 446                 }
 447
 448                 SETTING_TRACE_DEBUG("collection_step1 : %s", collection1);
 449
 450                 ret = setting_password_check_password(collection1, NULL, NULL);
 451                 if(ret != SETTING_RETURN_SUCCESS)
 452                 {
 453                         setting_password_main_draw_simple_password(ad, 3);
 454                         return SETTING_RETURN_FAIL;
 455                 }
 456                 ad->cur_pwd = (char*)strdup(collection1);
 457
 458                 /* reset static variables */
 459                 memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 460
 461                 if(ad->sp_entry1 == NULL || ad->sp_entry2 == NULL || ad->sp_entry3 == NULL || ad->sp_entry4 == NULL)
 462                         return SETTING_RETURN_FAIL;
 463
 464                 evas_object_event_callback_del(ad->sp_entry1, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 465                 evas_object_event_callback_del(ad->sp_entry2, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 466                 evas_object_event_callback_del(ad->sp_entry3, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 467                 evas_object_event_callback_del(ad->sp_entry4, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
 468
 469                 evas_object_smart_callback_del(ad->sp_entry1, "changed", _sp_changed_cb1);
 470                 evas_object_smart_callback_del(ad->sp_entry2, "changed", _sp_changed_cb2);
 471                 evas_object_smart_callback_del(ad->sp_entry3, "changed", _sp_changed_cb3);
 472                 evas_object_smart_callback_del(ad->sp_entry4, "changed", _sp_changed_cb4);
 473
 474                 if(ad->ly_main)
 475                 {
 476                         evas_object_del(ad->ly_main);
 477                         ad->ly_main = NULL;
 478                 }
 479                 if(ad->remove_timer)
 480                 {
 481                         ecore_timer_del(ad->remove_timer);
 482                         ad->remove_timer = NULL;
 483                 }
 484
 485 #ifdef SUPPORT_MDM
 486         if((ad->mdm_policy) && (ad->mdm_policy->quality != MDM_PASSWORD_QUALITY_UNSPECIFIED))
 487         {
 488                 ad->view_type = SETTING_PW_TYPE_MDM_NEW_POLICY;
 489                 ad->step1_str = ad->cur_pwd;
 490         }
 491         else
 492         {
 493                 ad->step1_str = NULL;
 494         }
 495 #endif
 496                 __create_common_password_frame(ad);
 497                 setting_password_main_draw_2line_password(ad, NULL);
 498         }
 499         else if(ad->is_simple_password_on == 0)
 500         {
 501                 SETTING_TRACE_DEBUG("case OFF->ON");
 502                 if(*step == 0) /* Enter new password */
 503                 {
 504                         _copy_chars_from_sp_entries(ad, collection1);
 505
 506                         ret = setting_password_main_check_simple_password(collection1);
 507                         if(ret < 0)
 508                         {
 509                                 setting_password_main_draw_simple_password(ad, 1);
 510                                 return SETTING_RETURN_FAIL;
 511                         }
 512                         (*step)++;
 513                         setting_password_main_draw_next_simple_password(ad, 2);
 514                 }
 515                 else if(*step == 1)     /* Enter password again */
 516                 {
 517                         _copy_chars_from_sp_entries(ad, collection2);
 518
 519                         ret = setting_password_main_check_simple_password(collection2);
 520                         if(ret < 0)
 521                         {
 522                                 setting_password_main_draw_simple_password(ad, 2);
 523                                 return SETTING_RETURN_FAIL;
 524                         }
 525
 526                         SETTING_TRACE_DEBUG("collection_step1 : %s", collection1);
 527                         SETTING_TRACE_DEBUG("collection_step2 : %s", collection2);
 528
 529                         /* compare two input passwords : collection_step1, collection_step2 */
 530                         if(safeStrNCmp(collection1, collection2, 4) == 0)
 531                         {
 532                                 ret = setting_password_set_password(ad->cur_pwd, collection1, ad);
 533                                 FREE(ad->cur_pwd);
 534
 535                                 /* Modify Setting Password */
 536                                 if (SETTING_RETURN_SUCCESS == ret) {
 537                                         SETTING_TRACE_DEBUG("success to save new password");
 538
 539                                         /* set vconfkey ON : if fail, try one more time. */
 540                                         if(vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, 1) < 0)
 541                                                 return SETTING_RETURN_FAIL;
 542                                         else
 543                                                 SETTING_TRACE_DEBUG("set vconfkey : simple password is ON");
 544
 545                                         /* Display popup */
 546                                         setting_password_ug_create_popup_notitle_nobtn(ad,
 547                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
 548
 549                                         *step = 0;
 550                                         /* reset static variables */
 551                                         memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 552                                         memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 553
 554                                         /* Correct Password. Send Bundle to caller for status change */
 555                                         service_h svc;
 556                                         if (service_create(&svc))
 557                                         {
 558                                                 setting_password_main_draw_simple_password(ad, 2);
 559                                                 return SETTING_RETURN_FAIL;
 560                                         }
 561
 562                                         service_add_extra_data(svc, "result", ad->view_type_string);
 563                                         ug_send_result(ad->ug, svc);
 564                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 565                                         service_destroy(svc);
 566                                         /* Send destroy request */
 567                                         ug_destroy_me(ad->ug);
 568                                 }
 569                                 else
 570                                 {
 571                                         setting_password_main_draw_simple_password(ad, 2);
 572                                         return SETTING_RETURN_FAIL;
 573                                 }
 574                         }
 575                         else
 576                         {
 577                                 setting_password_main_draw_simple_password(ad, 2);
 578                                 return SETTING_RETURN_FAIL;
 579                         }
 580                 }
 581         }
 582
 583         return SETTING_RETURN_SUCCESS;
 584 }
 585 #endif
 586
 587 static int _handle_step2(void *data, int *step, char *collection1, char*collection2)
 588 {
 589         retv_if(data == NULL, SETTING_RETURN_FAIL);
 590
 591         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 592         int ret = 0;
 593
 594         if(*step == 0)  /* Enter new password */
 595         {
 596                 _copy_chars_from_sp_entries(ad, collection1);
 597
 598                 ret = setting_password_main_check_simple_password(collection1);
 599                 if(ret < 0)
 600                 {
 601                         setting_password_main_draw_simple_password(ad, 1);
 602                         return SETTING_RETURN_FAIL;
 603                 }
 604                 (*step)++;
 605                 setting_password_main_draw_next_simple_password(ad, 2);
 606         }
 607         else if(*step == 1)     /* Enter password again */
 608         {
 609                 _copy_chars_from_sp_entries(ad, collection2);
 610
 611                 ret = setting_password_main_check_simple_password(collection2);
 612                 if(ret < 0)
 613                 {
 614                         setting_password_main_draw_simple_password(ad, 2);
 615                         return SETTING_RETURN_FAIL;
 616                 }
 617
 618                 /* compare two input passwords : collection_step1, collection_step2 */
 619                 if(safeStrNCmp(collection1, collection2, 4) == 0)
 620                 {
 621 #ifdef SUPPORT_MDM
 622                         if((ad->view_type == SETTING_PW_TYPE_MDM_TO_SIMPLE) && (ad->step1_str))
 623                         {
 624                                 ret = setting_password_set_password(ad->step1_str, collection1, ad);
 625                         }
 626                         else
 627 #endif
 628                         ret = setting_password_set_password(ad->cur_pwd, collection1, ad);
 629
 630                         if (SETTING_RETURN_SUCCESS == ret)
 631                         {
 632 #ifdef SUPPORT_MDM
 633                                 FREE(ad->step1_str);
 634 #endif
 635
 636                                 if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PASSWORD"))
 637                                 {
 638                                         int err;
 639                                         int ret;
 640
 641                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 642                                                                                                 SETTING_ON_OFF_BTN_ON, &err);
 643                                         retvm_if(ret < 0, SETTING_RETURN_FAIL, "[ERR] setting vconfkey failed.");
 644                                 }
 645 #ifdef SUPPORT_MDM
 646                                 else if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_MDM_CHANGE_PASSWORD"))
 647                                 {
 648                                         int err;
 649                                         int ret;
 650
 651                                         ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
 652                                                                                                 SETTING_ON_OFF_BTN_ON, &err);
 653                                         retvm_if(ret < 0, SETTING_RETURN_FAIL, "[ERR] setting vconfkey(phonelock) failed.");
 654
 655                                         ret = vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, TRUE);
 656                                         retvm_if(ret < 0, SETTING_RETURN_FAIL, "[ERR] setting vconfkey(simplepassword) failed.");
 657
 658                                         mdm_set_password_status(MDM_PASSWORD_CHANGED);
 659                                 }
 660 #endif
 661
 662                                 service_h svc;
 663                                 if (service_create(&svc))
 664                                         return SETTING_RETURN_FAIL;
 665
 666                                 service_add_extra_data(svc, "result", ad->view_type_string);
 667                                 service_add_extra_data(svc, "current", collection1);
 668                                 ug_send_result(ad->ug, svc);
 669                                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 670
 671                                 service_destroy(svc);
 672
 673                                 if(safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_RESET"))
 674                                         /* Display popup */
 675                                         setting_password_ug_create_popup_notitle_nobtn(ad,
 676                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
 677                                 /* Send destroy request */
 678                                 ug_destroy_me(ad->ug);
 679                         }
 680                         else
 681                         {
 682 #ifdef SUPPORT_MDM
 683                                 if(ad->notify)
 684                                 {
 685                                         evas_object_del(ad->notify);
 686                                         ad->notify = NULL;
 687                                 }
 688 #endif
 689                                 setting_password_main_draw_simple_password(ad, 1);
 690                         }
 691
 692                         *step = 0;
 693                         /* reset static variables */
 694                         memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 695                         memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 696                 }
 697                 else
 698                 {
 699                         setting_password_main_draw_simple_password(ad, 2);
 700                         return SETTING_RETURN_FAIL;
 701                 }
 702         }
 703         return SETTING_RETURN_SUCCESS;
 704 }
 705
 706 static int _handle_step3(void *data, int *step, char *collection1, char *collection2, char *collection3)
 707 {
 708         retv_if(data == NULL, SETTING_RETURN_FAIL);
 709
 710         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 711         int ret = 0;
 712         int err = 0;
 713
 714         char svalue[SHA256_DIGEST_LENGTH];
 715         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
 716
 717         if(*step == 0)  /* Enter current password */
 718         {
 719                 _copy_chars_from_sp_entries(ad, collection1);
 720
 721                 ret = setting_password_main_check_simple_password(collection1);
 722                 if(ret < 0)
 723                 {
 724                         setting_password_main_draw_simple_password(ad, 3);
 725                         return SETTING_RETURN_FAIL;
 726                 }
 727
 728                 ret = setting_password_check_password(collection1, NULL, NULL);
 729                 if(ret != SETTING_RETURN_SUCCESS)
 730                 {
 731                         setting_password_main_draw_simple_password(ad, 3);
 732                         return SETTING_RETURN_FAIL;
 733                 }
 734                 (*step)++;
 735                 setting_password_main_draw_next_simple_password(ad, 1);
 736         }
 737         else if(*step == 1)     /* Enter new password */
 738         {
 739                 _copy_chars_from_sp_entries(ad, collection2);
 740
 741                 ret = setting_password_main_check_simple_password(collection2);
 742                 if(ret < 0)
 743                 {
 744                         setting_password_main_draw_simple_password(ad, 1);
 745                         return SETTING_RETURN_FAIL;
 746                 }
 747
 748                 (*step)++;
 749                 setting_password_main_draw_next_simple_password(ad, 2);
 750         }
 751         else if(*step == 2)     /* Enter password again */
 752         {
 753                 _copy_chars_from_sp_entries(ad, collection3);
 754
 755                 ret = setting_password_main_check_simple_password(collection3);
 756                 if(ret < 0)
 757                 {
 758                         setting_password_main_draw_simple_password(ad, 2);
 759                         return SETTING_RETURN_FAIL;
 760                 }
 761
 762                 /* compare two input passwords : collection_step1, collection_step2 */
 763                 if(safeStrNCmp(collection2, collection3, 4) == 0)
 764                 {
 765                         ret = setting_password_set_password(collection1, collection2, ad);
 766                         /* Modify Setting Password */
 767                         if (SETTING_RETURN_FAIL != ret) {
 768                                 /* Display popup */
 769                                 setting_password_ug_create_popup_notitle_nobtn(ad,
 770                                                                         _("IDS_ST_POP_PASSWORD_CHANGED"), TRUE);
 771                         } else {
 772                                 /* Error Msg */
 773                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
 774                                                                         SETTING_FONT_RED, err, SETTING_FONT_BLACK);
 775                                 setting_password_ug_create_popup_notitle_nobtn(ad,
 776                                                                                 _("IDS_COM_POP_ERROR"), FALSE);
 777                         }
 778                 }
 779                 else
 780                 {
 781                         setting_password_main_draw_simple_password(ad, 2);
 782                         return SETTING_RETURN_FAIL;
 783                 }
 784                 *step = 0;
 785                 /* reset static variables */
 786                 memset(collection1, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 787                 memset(collection2, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 788                 memset(collection3, 0x00, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1);
 789
 790                 /* Send destroy request */
 791                 ug_destroy_me(ad->ug);
 792         }
 793         return SETTING_RETURN_SUCCESS;
 794 }
 795
 796 static int setting_password_main_done_simple_password(void *data, int on_locking)
 797 {
 798         SETTING_TRACE_BEGIN;
 799         retv_if(data == NULL, SETTING_RETURN_FAIL);
 800
 801         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 802
 803         static int step = 0;
 804
 805         static char collection_step1[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 806         static char collection_step2[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 807         static char collection_step3[SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH+1] = {0,};
 808
 809         switch(ad->view_type)
 810         {
 811                 case SETTING_PW_TYPE_SIMPLE_PASSWORD:
 812                         SETTING_TRACE_DEBUG("case SIMPLE_PASSWORD");
 813                         return _handle_step1(ad, collection_step1);
 814                         break;
 815                 case SETTING_PW_TYPE_SET_SIMPLE_PASSWORD:
 816 #ifdef SUPPORT_MDM
 817                 case SETTING_PW_TYPE_MDM_TO_SIMPLE:
 818 #endif
 819                         SETTING_TRACE_DEBUG("case SET_SIMPLE_PASSWORD");
 820                         return _handle_step2(ad, &step, collection_step1, collection_step2);
 821                         break;
 822                 case SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD:
 823                         SETTING_TRACE_DEBUG("case CHANGE_SIMPLE_PASSWORD");
 824                         return _handle_step3(ad, &step, collection_step1, collection_step2, collection_step3);
 825                         break;
 826                 default:
 827                         break;
 828         }
 829         return SETTING_RETURN_SUCCESS;
 830 }
 831
 832 static void _sp_changed_cb1(void *data, Evas_Object *obj, void *event_info)
 833 {
 834         ret_if(data == NULL);
 835
 836         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 837
 838         if((ad->sp_entry1 == NULL) || (ad->sp_entry1 != obj) || (ad->sp_entry2 == NULL))
 839                 return;
 840
 841         if(!elm_entry_is_empty(ad->sp_entry1) && elm_entry_is_empty(ad->sp_entry2))
 842         {
 843                 SETTING_TRACE_DEBUG("entry1 : %s", elm_entry_entry_get(ad->sp_entry1));
 844                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry1), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 845                         return;
 846                 /* focus on next entry */
 847                 elm_object_focus_set(ad->sp_entry2, EINA_TRUE);
 848                 elm_entry_entry_set(ad->sp_entry2, "<font_size=52 align=center>");
 849                 elm_entry_cursor_end_set(ad->sp_entry2);
 850                 ad->sp_focused = ad->sp_entry2;
 851         }
 852 }
 853
 854 static void _sp_changed_cb2(void *data, Evas_Object *obj, void *event_info)
 855 {
 856         ret_if(data == NULL);
 857
 858         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 859
 860         if((ad->sp_entry2 == NULL) || (ad->sp_entry2 != obj) || (ad->sp_entry3 == NULL))
 861                 return;
 862
 863         if(!elm_entry_is_empty(ad->sp_entry2) && elm_entry_is_empty(ad->sp_entry3))
 864         {
 865                 SETTING_TRACE_DEBUG("entry2 : %s", elm_entry_entry_get(ad->sp_entry2));
 866                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry2), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 867                         return;
 868                 /* focus on next entry */
 869                 elm_object_focus_set(ad->sp_entry3, EINA_TRUE);
 870                 elm_entry_entry_set(ad->sp_entry3, "<font_size=52 align=center>");
 871                 elm_entry_cursor_end_set(ad->sp_entry3);
 872                 ad->sp_focused = ad->sp_entry3;
 873         }
 874 }
 875
 876 static void _sp_changed_cb3(void *data, Evas_Object *obj, void *event_info)
 877 {
 878         ret_if(data == NULL);
 879
 880         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 881
 882         if((ad->sp_entry3 == NULL) || (ad->sp_entry3 != obj) || (ad->sp_entry4 == NULL))
 883                 return;
 884
 885         if(!elm_entry_is_empty(ad->sp_entry3) && elm_entry_is_empty(ad->sp_entry4))
 886         {
 887                 SETTING_TRACE_DEBUG("entry3 : %s", elm_entry_entry_get(ad->sp_entry3));
 888                 if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry3), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 889                         return;
 890                 /* focus on next entry */
 891                 elm_object_focus_set(ad->sp_entry4, EINA_TRUE);
 892                 elm_entry_entry_set(ad->sp_entry4, "<font_size=52 align=center>");
 893                 elm_entry_cursor_end_set(ad->sp_entry4);
 894                 ad->sp_focused = ad->sp_entry4;
 895         }
 896 }
 897
 898 static void _sp_changed_cb4(void *data, Evas_Object *obj, void *event_info)
 899 {
 900         ret_if(data == NULL);
 901
 902         static int counter = 0;
 903
 904         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 905
 906         if((ad->sp_entry4 == NULL) || (ad->sp_entry4 != obj))
 907                 return;
 908         if((ad->sp_entry1 == NULL) || (ad->sp_entry2 == NULL) || (ad->sp_entry3 == NULL))
 909                 return;
 910
 911         if(strcmp(elm_entry_entry_get(ad->sp_entry4), "") == 0)
 912         {
 913                 SETTING_TRACE_DEBUG("this is align text");
 914                 return;
 915         }
 916         if(safeStrNCmp(elm_entry_entry_get(ad->sp_entry4), "<font_size=52 align=center>", safeStrLen("<font_size=52 align=center>")) == 0)
 917                         return;
 918
 919         SETTING_TRACE_DEBUG("entry4 : %s", elm_entry_entry_get(ad->sp_entry4));
 920         /*  add this below for removing IMF faster */
 921         /*  need to discuss with IMF or Entry developer more */
 922         elm_object_focus_set(ad->sp_entry4, EINA_FALSE);
 923         /* end */
 924         counter++;
 925
 926         if(counter == ENTRY_CALLBACK_REPEAT_MAX)
 927         {
 928                 int ret = 0;
 929
 930                 ret = setting_password_main_done_simple_password(ad, TRUE);
 931
 932                 if(ret == SETTING_RETURN_FAIL)
 933                 {
 934                         setting_password_ug_display_desc(ad, _("IDS_ST_BODY_INCORRECT_PASSWORD_TRY_AGAIN"), FALSE);
 935                 }
 936                 else if(ret == SETTING_COMPARE_PW_FAIL)
 937                 {
 938                         if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_RESET")
 939                                 || 0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_ENTER_LOCK_TYPE"))
 940                         {
 941                                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_INCORRECT_PASSWORD"), FALSE);
 942                                 return;
 943                         }
 944
 945                         /** @todo setting_password_ug_check_attemps_left */
 946                         setting_int_slp_list item_attempts_left;
 947                         setting_str_slp_list item_lock_timestamp;
 948                         int attemps_left_max = 5;
 949
 950                         item_attempts_left = INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT;
 951                         item_lock_timestamp = STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP;
 952                         attemps_left_max = PHONE_LOCK_ATTEMPS_MAX;
 953
 954                         int value = -1;
 955                         int err = SETTING_RETURN_SUCCESS;
 956                         setting_get_int_slp_key(item_attempts_left, &value, &err);
 957                         setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] get value of vconf fail.");
 958
 959                         value--;
 960
 961                         if (value > 0 && value <= attemps_left_max) {
 962                                 setting_set_int_slp_key(item_attempts_left, value, &err);
 963                                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
 964
 965                                 char speciliztion[MAX_SPECIALIZITION_LEN] = { 0, };
 966                                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
 967
 968                                 if(value > 1)
 969                                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPTS_DESC);
 970                                 else
 971                                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPT_DESC);
 972
 973                                 snprintf(speciliztion, sizeof(speciliztion), temp, value);
 974                                 setting_password_ug_display_desc(ad, speciliztion, FALSE);
 975                         } else if (value == 0) {
 976                                 /*  store the lock timestamp */
 977                                 elm_object_focus_set(ad->sp_entry1, EINA_FALSE);
 978                                 time_t cur_time = time(NULL);
 979                                 char cur_timestamp[LOCK_TIMESTAMP_LEN] = { 0, };
 980                                 int ret = snprintf(cur_timestamp, sizeof(cur_timestamp), "%ld", cur_time);
 981                                 ret_if(ret < 0);
 982
 983                                 setting_set_string_slp_key(item_lock_timestamp, cur_timestamp, &err);
 984                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 985                                                                         "[Error] set value of vconf fail.");
 986
 987                                 setting_set_int_slp_key(item_attempts_left, value, &err);
 988                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 989                                                                         "[Error] set value of vconf fail.");
 990
 991                                 ad->disable_item_type = ad->view_type;
 992
 993                                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
 994                                 snprintf(temp, sizeof(temp), PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
 995                                 setting_password_ug_create_popup_notitle_nobtn(ad, temp, TRUE);
 996                         }
 997                 }
 998                 else
 999                 {
1000                         /* if you have more cases, modify here. */
1001                 }
1002                 counter = 0;
1003         }
1004         return;
1005 }
1006
1007 static char *__gl_sp_text_get(void *data, Evas_Object *obj, const char *part)
1008 {
1009         retv_if(data == NULL, NULL);
1010         SettingPasswordUG *ad = (SettingPasswordUG*)data;
1011
1012         SETTING_TRACE_DEBUG("[sp_label_get] label intex, %d", ad->sp_title_index);
1013
1014         if(ad->sp_title_index < SETTING_SP_TITLE_INDEX_START || ad->sp_title_index > SETTING_SP_TITLE_INDEX_MAX)
1015         {
1016                 SETTING_TRACE_DEBUG("title index is invalid");
1017                 return NULL;
1018         }
1019         else
1020         {
1021                 return strdup(_(sp_titles[ad->sp_title_index]));
1022         }
1023 }
1024
1025 static Evas_Object* __gl_sp_content_get(void *data, Evas_Object *obj, const char *part)
1026 {
1027         retv_if(data == NULL, NULL);
1028         SettingPasswordUG *ad = (SettingPasswordUG*)data;
1029
1030         Evas_Object *entry = NULL;
1031
1032         static Elm_Entry_Filter_Limit_Size limit_filter_data;
1033         limit_filter_data.max_byte_count = 0;
1034         limit_filter_data.max_char_count = 1;
1035
1036         entry = elm_entry_add(obj);
1037         elm_entry_password_set(entry, EINA_TRUE);
1038         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size, &limit_filter_data);
1039         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
1040         elm_entry_entry_set(entry, "<font_size=52 align=center>");
1041         evas_object_event_callback_add(entry, EVAS_CALLBACK_KEY_UP, _sp_back_key_up, ad);
1042
1043         elm_config_password_show_last_set(EINA_TRUE);
1044         elm_config_password_show_last_timeout_set(0.1);
1045
1046         if(safeStrCmp("elm.icon.1", part) == 0)
1047         {
1048                 SETTING_TRACE_DEBUG("create entry1");
1049                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb1, ad);
1050                 ad->sp_entry1 = entry;
1051         }
1052         else if(safeStrCmp("elm.icon.2", part) == 0)
1053         {
1054                 SETTING_TRACE_DEBUG("create entry2");
1055                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb2, ad);
1056                 ad->sp_entry2 = entry;
1057         }
1058         else if(safeStrCmp("elm.icon.3", part) == 0)
1059         {
1060                 SETTING_TRACE_DEBUG("create entry3");
1061                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb3, ad);
1062                 ad->sp_entry3 = entry;
1063         }
1064         else if(safeStrCmp("elm.icon.4", part) == 0)
1065         {
1066                 SETTING_TRACE_DEBUG("create entry4");
1067                 evas_object_smart_callback_add(entry, "changed", _sp_changed_cb4, ad);
1068                 ad->sp_entry4 = entry;
1069         }
1070
1071         return entry;
1072 }
1073
1074 static int
1075 setting_password_main_create(void *cb)
1076 {
1077         SETTING_TRACE_BEGIN;
1078         /* error check */
1079         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1080
1081         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1082         int ret = 0;
1083
1084         ad->itc_sp_bg_1icon.item_style = "dialogue/1text.4icon";
1085         ad->itc_sp_bg_1icon.func.text_get = __gl_sp_text_get;
1086         ad->itc_sp_bg_1icon.func.content_get = __gl_sp_content_get;
1087         ad->itc_sp_bg_1icon.func.state_get = NULL;
1088         ad->itc_sp_bg_1icon.func.del = NULL;
1089
1090         ret = __create_common_password_frame(ad);
1091
1092         if(ret < 0)
1093                 return SETTING_RETURN_FAIL;
1094
1095         setting_password_main_create_ui(ad);
1096
1097         setting_view_password_main.is_create = 1;
1098         SETTING_TRACE_END;
1099         return SETTING_RETURN_SUCCESS;
1100 }
1101
1102 static int setting_password_main_destroy(void *cb)
1103 {
1104         /* error check */
1105         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1106
1107         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1108         if (ad->remove_timer) {
1109                 ecore_timer_del(ad->remove_timer);
1110                 ad->remove_timer = NULL;
1111         }
1112 #ifdef SUPPORT_MDM
1113         if(ad->set_history_timer)
1114         {
1115                 ecore_timer_del(ad->set_history_timer);
1116                 ad->set_history_timer = NULL;
1117         }
1118 #endif
1119         if(     (ad->view_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
1120                         || (ad->view_type == SETTING_PW_TYPE_SET_SIMPLE_PASSWORD)
1121                         || (ad->view_type == SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD))
1122         {
1123                 evas_object_event_callback_del(ad->sp_entry1, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1124                 evas_object_event_callback_del(ad->sp_entry2, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1125                 evas_object_event_callback_del(ad->sp_entry3, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1126                 evas_object_event_callback_del(ad->sp_entry4, EVAS_CALLBACK_KEY_UP, _sp_back_key_up);
1127         }
1128 #ifdef SUPPORT_MDM
1129         if(ad->step1_str)
1130                 FREE(ad->step1_str);
1131 #endif
1132         if(ad->cur_pwd)
1133                 FREE(ad->cur_pwd);
1134
1135         if (ad->ly_main != NULL) {
1136                 evas_object_del(ad->ly_main);
1137                 ad->ly_main = NULL;
1138                 setting_view_password_main.is_create = 0;
1139         }
1140         return SETTING_RETURN_SUCCESS;
1141 }
1142
1143 static int setting_password_main_update(void *cb)
1144 {
1145         /* error check */
1146         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1147
1148         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1149
1150         if (ad->ly_main != NULL) {
1151                 evas_object_show(ad->ly_main);
1152         }
1153
1154         return SETTING_RETURN_SUCCESS;
1155 }
1156
1157 static int setting_password_main_cleanup(void *cb)
1158 {
1159         /* error check */
1160         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1161
1162         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
1163
1164         if (ad->ly_main != NULL) {
1165                 evas_object_hide(ad->ly_main);
1166         }
1167
1168         return SETTING_RETURN_SUCCESS;
1169 }
1170
1171 /* ***************************************************
1172  *
1173  *general func
1174  *
1175  ***************************************************/
1176
1177 static int setting_password_main_create_ui(void *data)
1178 {
1179         /* error check */
1180         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1181                  "[Setting > Password] Data parameter is NULL");
1182
1183         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1184
1185         SETTING_TRACE_DEBUG("ad->view_type=%d ***", ad->view_type);
1186
1187         switch (ad->view_type) {
1188         case SETTING_PW_TYPE_PASSWORD:
1189         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1190         case SETTING_PW_TYPE_PIN_LOCK_ON:
1191         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1192 #ifdef SUPPORT_MDM
1193         case SETTING_PW_TYPE_MDM_CHANGE_PASSWORD:
1194 #endif
1195                 setting_password_main_draw_1line_password(ad, NULL);
1196                 break;
1197         case SETTING_PW_TYPE_SIM_LOCK_ON:
1198         case SETTING_PW_TYPE_SET_PASSWORD:
1199 #ifdef SUPPORT_MDM
1200         case SETTING_PW_TYPE_MDM_NEW_POLICY:
1201 #endif
1202                 setting_password_main_draw_2line_password(ad, NULL);
1203                 break;
1204
1205         case SETTING_PW_TYPE_CHANGE_PASSWORD:
1206         case SETTING_PW_TYPE_CHANGE_PIN1:
1207         case SETTING_PW_TYPE_CHANGE_PIN2:
1208         case SETTING_PW_TYPE_PIN1_BLOCKED:
1209         case SETTING_PW_TYPE_PIN2_BLOCKED:
1210                 setting_password_main_draw_3line_password(ad, NULL);
1211                 break;
1212
1213         case SETTING_PW_TYPE_SET_SIMPLE_PASSWORD:
1214 #ifdef SUPPORT_MDM
1215         case SETTING_PW_TYPE_MDM_TO_SIMPLE:
1216 #endif
1217                 setting_password_main_draw_simple_password(ad, 1);
1218
1219                 break;
1220
1221         case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1222         case SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD:
1223                 setting_password_main_draw_simple_password(ad, 3);
1224                 break;
1225
1226         default:
1227                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
1228                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
1229                 break;
1230         }
1231
1232         /** @todo this function always return 0, not verifying the function flow with the value */
1233         return 0;
1234 }
1235
1236 static void
1237 setting_password_main_entry_changed_cb(void *data, Evas_Object *obj,
1238                                        void *event_info)
1239 {
1240         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
1241         Setting_GenGroupItem_Data *list_item =
1242             (Setting_GenGroupItem_Data *) data;
1243         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
1244         const char *entry_str = elm_entry_entry_get(obj);
1245         list_item->sub_desc = (char *)g_strdup(entry_str);
1246         bool isFoundEmptyEntry = FALSE;
1247
1248         Evas_Object *layout = elm_object_parent_widget_get(obj);
1249         elm_object_part_text_set(layout, "elm.guidetext", "");
1250
1251         do {
1252                 if (ad->ed_pw1) {
1253                         entry_str = ad->ed_pw1->sub_desc;
1254                         if (NULL == entry_str || '\0' == entry_str[0]) {
1255                                 isFoundEmptyEntry = TRUE;
1256                                 layout = elm_object_parent_widget_get(ad->ed_pw1->eo_check);
1257                                 elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1258                                 break;
1259                         }
1260                 }
1261                 if (ad->ed_pw2) {
1262                         entry_str = ad->ed_pw2->sub_desc;
1263                         if (NULL == entry_str || '\0' == entry_str[0]) {
1264                                 isFoundEmptyEntry = TRUE;
1265                                 layout = elm_object_parent_widget_get(ad->ed_pw2->eo_check);
1266                                 elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1267                                 break;
1268                         }
1269                 }
1270                 if (ad->ed_pw3) {
1271                         entry_str = ad->ed_pw3->sub_desc;
1272                         if (NULL == entry_str || '\0' == entry_str[0]) {
1273                                 isFoundEmptyEntry = TRUE;
1274                                 layout = elm_object_parent_widget_get(ad->ed_pw3->eo_check);
1275                                 elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1276                                 break;
1277                         }
1278                 }
1279
1280         } while (0);
1281
1282         bool disableFlag = isFoundEmptyEntry;
1283
1284         #if SUPPORT_BOTTOM_BTNS
1285         Evas_Object *done_btn = elm_object_item_part_content_get(ad->navi_it, NAVI_BTN_STYLE_LEFT);
1286         if (disableFlag) {
1287                 if (!evas_object_pass_events_get(done_btn)) { /* it had not yet been disabled */
1288                         setting_disable_evas_object(done_btn);
1289                         setting_dim_evas_object(done_btn, TRUE);
1290                 }/* else already disabled */
1291         } else {
1292                 setting_enable_evas_object(done_btn);
1293                 setting_undo_dim_evas_object(done_btn, TRUE);
1294         }
1295         #else
1296         elm_object_item_disabled_set(elm_toolbar_last_item_get
1297                                          (ad->controllbar), disableFlag);
1298         #endif
1299
1300 }
1301
1302 static Eina_Bool __focus_sp_on_idler(void *data)
1303 {
1304         /* error check */
1305         retv_if(data == NULL, FALSE);
1306
1307         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1308
1309         if(ad->sp_entry1)
1310         {
1311                 elm_object_focus_set(ad->sp_entry1, EINA_TRUE);
1312                 ad->sp_focused = ad->sp_entry1;
1313         }
1314
1315         return ECORE_CALLBACK_CANCEL;
1316 }
1317
1318 static Eina_Bool __focus_on_idler(void *data)
1319 {
1320         /* error check */
1321         retv_if(data == NULL, FALSE);
1322
1323         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1324
1325         if(ad->ed_pw1)
1326         {
1327                 if (ad->ed_pw1->isFocusFlag || (ad->ed_pw1->eo_check != NULL))
1328                 {
1329                         /* no matter how many edifileds, it only need focus on 1st editfiled */
1330                         elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
1331                 }
1332         }
1333
1334         return ECORE_CALLBACK_CANCEL;
1335 }
1336
1337
1338 static int setting_password_main_draw_next_simple_password(void *data, int title_index)
1339 {
1340         /* error check */
1341         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1342                  "[Setting > Password] Data parameter is NULL");
1343
1344         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1345
1346         setting_password_main_draw_simple_password(ad, title_index);
1347
1348         return SETTING_RETURN_SUCCESS;
1349 }
1350
1351 static int setting_password_main_draw_simple_password(void *data, int title_index)
1352 {
1353         /* error check */
1354         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1355                  "[Setting > Password] Data parameter is NULL");
1356
1357         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1358
1359         switch (ad->view_type) {
1360                 case SETTING_PW_TYPE_SIMPLE_PASSWORD:
1361                 case SETTING_PW_TYPE_SET_SIMPLE_PASSWORD:
1362                 case SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD:
1363 #ifdef SUPPORT_MDM
1364                 case SETTING_PW_TYPE_MDM_TO_SIMPLE:
1365 #endif
1366                         ad->sp_title_index = title_index;
1367
1368                         if(ad->sp_item != NULL)
1369                         {
1370                                 elm_genlist_item_update(ad->sp_item);
1371                         }
1372                         else
1373                         {
1374                                 elm_genlist_clear(ad->scroller);
1375                         ad->sp_item = elm_genlist_item_append(ad->scroller, &(ad->itc_sp_bg_1icon), ad, NULL,
1376                                                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1377                         }
1378 #ifdef SUPPORT_MDM
1379                         if(ad->view_type == SETTING_PW_TYPE_MDM_TO_SIMPLE)
1380                         {
1381                                 if(ad->is_expired == SETTING_PW_STATUS_EXPIRED)
1382                                         setting_password_ug_display_mdm_desc(ad, PASSWORD_EXPIRED);
1383                                 else
1384                                         setting_password_ug_display_mdm_desc(ad, NEW_PASSWORD_NECESSARY);
1385                         }
1386 #endif
1387
1388                         ecore_idler_add(__focus_sp_on_idler, ad);
1389                 default:
1390                         break;
1391         }
1392         return 0;
1393 }
1394
1395 static int setting_password_main_draw_1line_password(void *data, void *cb)
1396 {
1397         /* error check */
1398         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1399                  "[Setting > Password] Data parameter is NULL");
1400
1401         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1402
1403         switch (ad->view_type) {
1404         case SETTING_PW_TYPE_PASSWORD:
1405 #ifdef SUPPORT_MDM
1406         case SETTING_PW_TYPE_MDM_CHANGE_PASSWORD:
1407 #endif
1408                 ad->ed_pw1 =
1409                     setting_create_Gendial_field_entry(ad->scroller,
1410                                                        &
1411                                                        (ad->itc_variable_height),
1412                                                        NULL, ad,
1413                                                        SWALLOW_Type_LAYOUT_ENTRY,
1414                                                        NULL, NULL, 0,
1415                                                        "IDS_COM_BODY_PASSWORD",
1416                                                        NULL,
1417                                                        setting_password_main_entry_changed_cb,
1418                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1419                                                        TRUE, TRUE,
1420                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1421                                                        0, NULL, NULL);
1422                 break;
1423         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1424                 ad->ed_pw1 =
1425                     setting_create_Gendial_field_entry(ad->scroller,
1426                                                        &
1427                                                        (ad->itc_variable_height),
1428                                                        NULL, ad,
1429                                                        SWALLOW_Type_LAYOUT_ENTRY,
1430                                                        NULL, NULL, 0,
1431                                                        "IDS_ST_BODY_SIM_PASSWORD",
1432                                                        NULL,
1433                                                        setting_password_main_entry_changed_cb,
1434                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1435                                                        TRUE, TRUE,
1436                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1437                                                        0, "0123456789", NULL);
1438                 break;
1439
1440         case SETTING_PW_TYPE_PIN_LOCK_ON:
1441         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1442                 ad->ed_pw1 =
1443                     setting_create_Gendial_field_entry(ad->scroller,
1444                                                        &
1445                                                        (ad->itc_variable_height),
1446                                                        NULL, ad,
1447                                                        SWALLOW_Type_LAYOUT_ENTRY,
1448                                                        NULL, NULL, 0,
1449                                                        "IDS_ST_BODY_PIN1", NULL,
1450                                                        setting_password_main_entry_changed_cb,
1451                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1452                                                        TRUE, TRUE,
1453                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1454                                                        0, "0123456789", NULL);
1455                 break;
1456
1457         default:
1458                 break;
1459         }
1460         ecore_idler_add(__focus_on_idler, ad);
1461         return 0;
1462 }
1463
1464 static int setting_password_main_clear_1line_password(void *data)
1465 {
1466         /* error check */
1467         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1468                  "[Setting > Password] Data parameter is NULL");
1469
1470         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1471         retv_if(NULL == ad->ed_pw1, -1);
1472
1473         ad->ed_pw1->sub_desc = NULL;
1474         ad->ed_pw1->isFocusFlag = FALSE;
1475
1476         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1477         Evas_Object *layout = elm_object_parent_widget_get(ad->ed_pw1->eo_check);
1478         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1479         return 0;
1480 }
1481
1482 static int setting_password_main_draw_2line_password(void *data, void *cb)
1483 {
1484         /* error check */
1485         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1486
1487         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1488
1489         switch (ad->view_type) {
1490         case SETTING_PW_TYPE_SET_PASSWORD:
1491 #ifdef SUPPORT_MDM
1492         case SETTING_PW_TYPE_MDM_NEW_POLICY:
1493 #endif
1494                 ad->ed_pw1 =
1495                     setting_create_Gendial_field_entry(ad->scroller,
1496                                                        &
1497                                                        (ad->itc_variable_height),
1498                                                        NULL, ad,
1499                                                        SWALLOW_Type_LAYOUT_ENTRY,
1500                                                        NULL, NULL, 0,
1501                                                        PW_SHORT_GUIDE_NEW,
1502                                                        NULL,
1503                                                        setting_password_main_entry_changed_cb,
1504                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1505                                                        TRUE, TRUE,
1506                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1507                                                        0, NULL, NULL);
1508
1509                 ad->ed_pw2 =
1510                     setting_create_Gendial_field_entry(ad->scroller,
1511                                                        &
1512                                                        (ad->itc_variable_height),
1513                                                        NULL, ad,
1514                                                        SWALLOW_Type_LAYOUT_ENTRY,
1515                                                        NULL, NULL, 0,
1516                                                        PW_SHORT_GUIDE_CONFIRM,
1517                                                        NULL,
1518                                                        setting_password_main_entry_changed_cb,
1519                                                        ELM_INPUT_PANEL_LAYOUT_NORMAL,
1520                                                        TRUE, FALSE,
1521                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1522                                                        0, NULL, NULL);
1523 #ifdef SUPPORT_MDM
1524                 if(ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
1525                 {
1526                         if(ad->is_expired == SETTING_PW_STATUS_EXPIRED)
1527                         {
1528                                 setting_password_ug_display_mdm_desc(ad, PASSWORD_EXPIRED);
1529                         }
1530                         else
1531                         {
1532                                 setting_password_ug_display_mdm_desc(ad, NEW_PASSWORD_NECESSARY);
1533                         }
1534                 }
1535
1536 #endif
1537                 break;
1538
1539         case SETTING_PW_TYPE_SIM_LOCK_ON:
1540                 ad->ed_pw1 =
1541                     setting_create_Gendial_field_entry(ad->scroller,
1542                                                        &
1543                                                        (ad->itc_variable_height),
1544                                                        NULL, ad,
1545                                                        SWALLOW_Type_LAYOUT_ENTRY,
1546                                                        NULL, NULL, 0,
1547                                                        PW_SHORT_GUIDE_NEW,
1548                                                        NULL,
1549                                                        setting_password_main_entry_changed_cb,
1550                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1551                                                        TRUE, TRUE,
1552                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1553                                                        0, "0123456789", NULL);
1554
1555                 ad->ed_pw2 =
1556                     setting_create_Gendial_field_entry(ad->scroller,
1557                                                        &
1558                                                        (ad->itc_variable_height),
1559                                                        NULL, ad,
1560                                                        SWALLOW_Type_LAYOUT_ENTRY,
1561                                                        NULL, NULL, 0,
1562                                                        PW_SHORT_GUIDE_CONFIRM,
1563                                                        NULL,
1564                                                        setting_password_main_entry_changed_cb,
1565                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1566                                                        TRUE, FALSE,
1567                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
1568                                                        0, "0123456789", NULL);
1569                 break;
1570
1571         default:
1572                 break;
1573         }
1574         ecore_idler_add(__focus_on_idler, ad);
1575         return 0;
1576 }
1577
1578 static int setting_password_main_clear_2line_password(void *data)
1579 {
1580         /* error check */
1581         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1582                  "[Setting > Password] Data parameter is NULL");
1583
1584         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1585         Evas_Object *layout = NULL;
1586
1587         retv_if(NULL == ad->ed_pw1, -1);
1588         ad->ed_pw1->sub_desc = NULL;
1589         ad->ed_pw1->isFocusFlag = FALSE;
1590         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1591         layout = elm_object_parent_widget_get(ad->ed_pw1->eo_check);
1592         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1593
1594         retv_if(NULL == ad->ed_pw2, -1);
1595         ad->ed_pw2->sub_desc = NULL;
1596         ad->ed_pw2->isFocusFlag = FALSE;
1597         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
1598         layout = elm_object_parent_widget_get(ad->ed_pw2->eo_check);
1599         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1600         return 0;
1601 }
1602
1603 static int setting_password_main_draw_3line_password(void *data, void *cb)
1604 {
1605         /* error check */
1606         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1607                  "[Setting > Password] Data parameter is NULL");
1608
1609         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1610         Elm_Input_Panel_Layout ime_style = ELM_INPUT_PANEL_LAYOUT_NORMAL;
1611
1612         switch (ad->view_type) {
1613         case SETTING_PW_TYPE_CHANGE_PASSWORD:
1614                 ad->ed_pw1 =
1615                     setting_create_Gendial_field_entry(ad->scroller,
1616                                                        &
1617                                                        (ad->itc_variable_height),
1618                                                        NULL, ad,
1619                                                        SWALLOW_Type_LAYOUT_ENTRY,
1620                                                        NULL, NULL, 0,
1621                                                        "IDS_ST_BODY_CURRENT_PASSWORD",
1622                                                        NULL,
1623                                                        setting_password_main_entry_changed_cb,
1624                                                        ime_style,
1625                                                        TRUE, TRUE,
1626                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1627                                                        0, NULL, NULL);
1628
1629                 ad->ed_pw2 =
1630                     setting_create_Gendial_field_entry(ad->scroller,
1631                                                        &
1632                                                        (ad->itc_variable_height),
1633                                                        NULL, ad,
1634                                                        SWALLOW_Type_LAYOUT_ENTRY,
1635                                                        NULL, NULL, 0,
1636                                                        "IDS_ST_BODY_NEW_PASSWORD",
1637                                                        NULL,
1638                                                        setting_password_main_entry_changed_cb,
1639                                                        ime_style,
1640                                                        TRUE, FALSE,
1641                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1642                                                        0, NULL, NULL);
1643
1644                 ad->ed_pw3 =
1645                     setting_create_Gendial_field_entry(ad->scroller,
1646                                                        &
1647                                                        (ad->itc_variable_height),
1648                                                        NULL, ad,
1649                                                        SWALLOW_Type_LAYOUT_ENTRY,
1650                                                        NULL, NULL, 0,
1651                                                        "IDS_ST_BODY_CONFIRM_PASSWORD",
1652                                                        NULL,
1653                                                        setting_password_main_entry_changed_cb,
1654                                                        ime_style,
1655                                                        TRUE, FALSE,
1656                                                        SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
1657                                                        0, NULL, NULL);
1658 #ifdef SUPPORT_MDM
1659                 if(ad->mdm_data != NULL)
1660                 {
1661                         ad->mdm_policy = (mdm_password_policy_t*)(ad->mdm_data->data);
1662
1663                         if(ad->mdm_policy->quality != MDM_PASSWORD_QUALITY_UNSPECIFIED)
1664                                 elm_genlist_item_append(ad->scroller, &(ad->itc_mdm_desc), ad, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1665                 }
1666 #endif
1667                 break;
1668
1669         case SETTING_PW_TYPE_CHANGE_PIN1:
1670                 ad->ed_pw1 =
1671                     setting_create_Gendial_field_entry(ad->scroller,
1672                                                        &
1673                                                        (ad->itc_variable_height),
1674                                                        NULL, ad,
1675                                                        SWALLOW_Type_LAYOUT_ENTRY,
1676                                                        NULL, NULL, 0,
1677                                                        PW_SHORT_GUIDE_CURRENT,
1678                                                        NULL,
1679                                                        setting_password_main_entry_changed_cb,
1680                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1681                                                        TRUE, TRUE,
1682                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1683                                                        0, "0123456789", NULL);
1684
1685                 ad->ed_pw2 =
1686                     setting_create_Gendial_field_entry(ad->scroller,
1687                                                        &
1688                                                        (ad->itc_variable_height),
1689                                                        NULL, ad,
1690                                                        SWALLOW_Type_LAYOUT_ENTRY,
1691                                                        NULL, NULL, 0,
1692                                                        PW_SHORT_GUIDE_NEW,
1693                                                        NULL,
1694                                                        setting_password_main_entry_changed_cb,
1695                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1696                                                        TRUE, FALSE,
1697                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1698                                                        0, "0123456789", NULL);
1699
1700                 ad->ed_pw3 =
1701                     setting_create_Gendial_field_entry(ad->scroller,
1702                                                        &
1703                                                        (ad->itc_variable_height),
1704                                                        NULL, ad,
1705                                                        SWALLOW_Type_LAYOUT_ENTRY,
1706                                                        NULL, NULL, 0,
1707                                                        PW_SHORT_GUIDE_CONFIRM,
1708                                                        NULL,
1709                                                        setting_password_main_entry_changed_cb,
1710                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1711                                                        TRUE, FALSE,
1712                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1713                                                        0, "0123456789", NULL);
1714                 break;
1715
1716         case SETTING_PW_TYPE_CHANGE_PIN2:
1717                 ad->ed_pw1 =
1718                     setting_create_Gendial_field_entry(ad->scroller,
1719                                                        &
1720                                                        (ad->itc_variable_height),
1721                                                        NULL, ad,
1722                                                        SWALLOW_Type_LAYOUT_ENTRY,
1723                                                        NULL, NULL, 0,
1724                                                        PW_SHORT_GUIDE_CURRENT,
1725                                                        NULL,
1726                                                        setting_password_main_entry_changed_cb,
1727                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1728                                                        TRUE, TRUE,
1729                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1730                                                        0, "0123456789", NULL);
1731
1732                 ad->ed_pw2 =
1733                     setting_create_Gendial_field_entry(ad->scroller,
1734                                                        &
1735                                                        (ad->itc_variable_height),
1736                                                        NULL, ad,
1737                                                        SWALLOW_Type_LAYOUT_ENTRY,
1738                                                        NULL, NULL, 0,
1739                                                        PW_SHORT_GUIDE_NEW,
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                                                        &
1750                                                        (ad->itc_variable_height),
1751                                                        NULL, ad,
1752                                                        SWALLOW_Type_LAYOUT_ENTRY,
1753                                                        NULL, NULL, 0,
1754                                                        PW_SHORT_GUIDE_CONFIRM,
1755                                                        NULL,
1756                                                        setting_password_main_entry_changed_cb,
1757                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1758                                                        TRUE, FALSE,
1759                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1760                                                        0, "0123456789", NULL);
1761                 break;
1762
1763         case SETTING_PW_TYPE_PIN1_BLOCKED:
1764                 ad->ed_pw1 =
1765                     setting_create_Gendial_field_entry(ad->scroller,
1766                                                        &
1767                                                        (ad->itc_variable_height),
1768                                                        NULL, ad,
1769                                                        SWALLOW_Type_LAYOUT_ENTRY,
1770                                                        NULL, NULL, 0,
1771                                                        "IDS_ST_BODY_PUK1_CODE",
1772                                                        NULL,
1773                                                        setting_password_main_entry_changed_cb,
1774                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1775                                                        TRUE, TRUE,
1776                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1777                                                        0, "0123456789", NULL);
1778
1779                 ad->ed_pw2 =
1780                     setting_create_Gendial_field_entry(ad->scroller,
1781                                                        &
1782                                                        (ad->itc_variable_height),
1783                                                        NULL, ad,
1784                                                        SWALLOW_Type_LAYOUT_ENTRY,
1785                                                        NULL, NULL, 0,
1786                                                        "IDS_ST_BODY_NEW_PIN1",
1787                                                        NULL,
1788                                                        setting_password_main_entry_changed_cb,
1789                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1790                                                        TRUE, FALSE,
1791                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1792                                                        0, "0123456789", NULL);
1793
1794                 ad->ed_pw3 =
1795                     setting_create_Gendial_field_entry(ad->scroller,
1796                                                        &
1797                                                        (ad->itc_variable_height),
1798                                                        NULL, ad,
1799                                                        SWALLOW_Type_LAYOUT_ENTRY,
1800                                                        NULL, NULL, 0,
1801                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN1",
1802                                                        NULL,
1803                                                        setting_password_main_entry_changed_cb,
1804                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1805                                                        TRUE, FALSE,
1806                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1807                                                        0, "0123456789", NULL);
1808                 break;
1809
1810         case SETTING_PW_TYPE_PIN2_BLOCKED:
1811                 ad->ed_pw1 =
1812                     setting_create_Gendial_field_entry(ad->scroller,
1813                                                        &
1814                                                        (ad->itc_variable_height),
1815                                                        NULL, ad,
1816                                                        SWALLOW_Type_LAYOUT_ENTRY,
1817                                                        NULL, NULL, 0,
1818                                                        "IDS_ST_BODY_PUK2", NULL,
1819                                                        setting_password_main_entry_changed_cb,
1820                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1821                                                        TRUE, TRUE,
1822                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1823                                                        0, "0123456789", NULL);
1824
1825                 ad->ed_pw2 =
1826                     setting_create_Gendial_field_entry(ad->scroller,
1827                                                        &
1828                                                        (ad->itc_variable_height),
1829                                                        NULL, ad,
1830                                                        SWALLOW_Type_LAYOUT_ENTRY,
1831                                                        NULL, NULL, 0,
1832                                                        "IDS_ST_BODY_NEW_PIN2",
1833                                                        NULL,
1834                                                        setting_password_main_entry_changed_cb,
1835                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1836                                                        TRUE, FALSE,
1837                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1838                                                        0, "0123456789", NULL);
1839
1840                 ad->ed_pw3 =
1841                     setting_create_Gendial_field_entry(ad->scroller,
1842                                                        &
1843                                                        (ad->itc_variable_height),
1844                                                        NULL, ad,
1845                                                        SWALLOW_Type_LAYOUT_ENTRY,
1846                                                        NULL, NULL, 0,
1847                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN2",
1848                                                        NULL,
1849                                                        setting_password_main_entry_changed_cb,
1850                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1851                                                        TRUE, FALSE,
1852                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1853                                                        0, "0123456789", NULL);
1854                 break;
1855
1856         default:
1857                 break;
1858         }
1859         ecore_idler_add(__focus_on_idler, ad);
1860         return 0;
1861 }
1862
1863 static int setting_password_main_clear_3line_password(void *data)
1864 {
1865         /* error check */
1866         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1867                  "[Setting > Password] Data parameter is NULL");
1868
1869         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1870         Evas_Object *layout = NULL;
1871
1872         retv_if(NULL == ad->ed_pw1, -1);
1873         ad->ed_pw1->sub_desc = NULL;
1874         ad->ed_pw1->isFocusFlag = FALSE;
1875         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1876         layout = elm_object_parent_widget_get(ad->ed_pw1->eo_check);
1877         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1878
1879         retv_if(NULL == ad->ed_pw2, -1);
1880         ad->ed_pw2->sub_desc = NULL;
1881         ad->ed_pw2->isFocusFlag = FALSE;
1882         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
1883         layout = elm_object_parent_widget_get(ad->ed_pw2->eo_check);
1884         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1885
1886         retv_if(NULL == ad->ed_pw3, -1);
1887         ad->ed_pw3->sub_desc = NULL;
1888         ad->ed_pw3->isFocusFlag = FALSE;
1889         elm_entry_entry_set(ad->ed_pw3->eo_check, "");
1890         layout = elm_object_parent_widget_get(ad->ed_pw3->eo_check);
1891         elm_object_part_text_set(layout, "elm.guidetext", _("IDS_ST_BODY_TAP_TO_INSERT"));
1892         return 0;
1893 }
1894
1895 static int setting_password_main_check_simple_password(const char *collection)
1896 {
1897         retv_if(collection == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1898
1899         int sp_len = safeStrLen(collection);
1900         int index = 0;
1901         char temp;
1902
1903         SETTING_TRACE_DEBUG("collection length is %d", sp_len);
1904
1905         if(sp_len != 4)
1906                 return SETTING_RETURN_FAIL;
1907
1908         /* check if digit. */
1909         for(index = 0; index < sp_len; index++)
1910         {
1911                 temp = (char)(collection[index]);
1912                 if((temp < '0') || ( temp > '9'))
1913                         return SETTING_RETURN_FAIL;
1914                 else
1915                         SETTING_TRACE_DEBUG("temp %c", temp);
1916         }
1917
1918         return SETTING_RETURN_SUCCESS;
1919 }
1920
1921 static int setting_password_main_check_1line_password(void *data)
1922 {
1923         /* error check */
1924         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1925
1926         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1927
1928         const char *entry_str = ad->ed_pw1->sub_desc;
1929         ad->focus_data = ad->ed_pw1;
1930
1931         /*  Empty Check */
1932         if (isEmptyStr(entry_str)) {
1933 #ifdef SUPPORT_POPUP
1934                 setting_password_ug_create_popup_notitle_nobtn(ad,
1935                                                                _("IDS_ST_BODY_PASSWORD_EMPTY"),
1936                                                                FALSE);
1937 #else
1938                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
1939
1940 #endif
1941                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
1942         }
1943
1944         /*  Length Check */
1945         int entry_str_len = safeStrLen(entry_str);
1946         switch (ad->view_type) {
1947         case SETTING_PW_TYPE_PASSWORD:
1948                 {
1949                         if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
1950                             || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH)
1951                         {
1952                                 setting_password_main_warning_entry_added_byte_popup(ad,
1953                                         SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
1954                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1955                         }
1956 #ifdef SUPPORT_MDM
1957                         int letter = 0;
1958                         int digit = 0;
1959                         int symbol = 0;
1960
1961                         if( _count_string(entry_str, &letter, &digit, &symbol) == SETTING_RETURN_SUCCESS)
1962                         {
1963                                 if(letter < 1)
1964                                         return SETTING_PW_ERROR_INCLUDE_NO_LETTER;
1965                         }
1966 #endif
1967                 }
1968                 break;
1969         case SETTING_PW_TYPE_PIN_LOCK_ON:
1970         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1971                 {
1972                         if (entry_str_len < SETTING_PW_UG_PIN_MIN_LENGTH
1973                             || entry_str_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
1974                                 setting_password_main_warning_entry_added_byte_popup
1975                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
1976                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1977                         }
1978                 }
1979                 break;
1980         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1981                 {
1982                         if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
1983                             || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH) {
1984                                 setting_password_main_warning_entry_added_byte_popup
1985                                         (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
1986                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1987                         }
1988                 }
1989         default:
1990                 break;
1991         }
1992         return SETTING_RETURN_SUCCESS;
1993 }
1994
1995 #ifdef SUPPORT_MDM
1996 int _count_string(const char *str, int *cnt_letter, int *cnt_digit, int *cnt_sym)
1997 {
1998         SETTING_TRACE_BEGIN;
1999         retv_if(str == NULL || cnt_letter == NULL || cnt_digit == NULL || cnt_sym == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2000
2001         int length = strlen(str);
2002         int index = 0;
2003         char temp = 0;
2004         int letter = 0;
2005         int digit = 0;
2006         int symbol = 0;
2007
2008         if(length <= 0)
2009         {
2010                 SETTING_TRACE_DEBUG("[DEBUG] invalid input length");
2011                 return SETTING_RETURN_FAIL;
2012         }
2013
2014         for(index = 0; index < length; index++)
2015         {
2016                 temp = (char)(str[index]);
2017                 SETTING_TRACE_DEBUG("temp %c", temp);
2018
2019                 if((temp >= '0') && (temp <= '9'))      /* digit */
2020                 {
2021                         digit++;
2022                 }
2023                 else if((temp >= 'a') && (temp <= 'z')) /* lower letter */
2024                 {
2025                         letter++;
2026                 }
2027                 else if((temp >= 'A') && (temp <= 'Z')) /* upper letter */
2028                 {
2029                         letter++;
2030                 }
2031                 else if((temp >= ' ') && (temp <= '~')) /* symbol means special char that enables to input from IME. */
2032                 {
2033                         symbol++;
2034                 }
2035         }
2036         SETTING_TRACE_DEBUG("%s includes %d letters, %d digits, and %d symbols", str, letter, digit, symbol);
2037         *cnt_letter = letter;
2038         *cnt_digit = digit;
2039         *cnt_sym = symbol;
2040         return SETTING_RETURN_SUCCESS;
2041 }
2042
2043 int _check_min_length(int str_length, int min_length)
2044 {
2045         /* if min_length is 0~3, it operates the same as 4. */
2046         if((min_length < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH)
2047                 && (str_length < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH))
2048         {
2049                 return SETTING_RETURN_FAIL;
2050         }
2051         else if(min_length < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH)
2052         {
2053                 /* do nothing */
2054         }
2055         else if((min_length > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH)
2056                 || (str_length > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH))
2057         {
2058                 return SETTING_RETURN_FAIL;
2059         }
2060         else if(min_length > str_length)
2061         {
2062                 return SETTING_RETURN_FAIL;
2063         }
2064
2065         return SETTING_RETURN_SUCCESS;
2066 }
2067
2068 int _check_min_complex(int min_complex, int digit, int symbol)
2069 {
2070         switch(min_complex)
2071         {
2072                 case 0:
2073                 case 1:
2074                         if(digit < 1)
2075                         {
2076                                 SETTING_TRACE_DEBUG("[ERROR] should include 1 digit at list.");
2077                                 return SETTING_RETURN_FAIL;
2078                         }
2079                         break;
2080                 case 2:
2081                         if((digit < 1) || (symbol < 1))
2082                         {
2083                                 SETTING_TRACE_DEBUG("[ERROR] should include 1 digit and 1 symbol at list.");
2084                                 return SETTING_RETURN_FAIL;
2085                         }
2086                         break;
2087                 case 3:
2088                         if((digit >= 1) && (symbol >= 2))
2089                         {
2090                                 /* do nothing */
2091                         }
2092                         else if((digit >= 2) && (symbol >= 1))
2093                         {
2094                                 /* do nothing */
2095                         }
2096                         else
2097                         {
2098                                 SETTING_TRACE_DEBUG("[ERROR] digits or symbols are not enough.");
2099                                 return SETTING_RETURN_FAIL;
2100                         }
2101                         break;
2102                 case 4:
2103                         if((digit >= 1) && (symbol >= 3))
2104                         {
2105                                 /* do nothing */
2106                         }
2107                         else if((digit >= 3) && (symbol >= 1))
2108                         {
2109                                 /* do nothing */
2110                         }
2111                         else if((digit >= 2) && (symbol >= 2))
2112                         {
2113                                 /* do nothing */
2114                         }
2115                         else
2116                         {
2117                                 SETTING_TRACE_DEBUG("[ERROR] digits or symbols are not enough.");
2118                                 return SETTING_RETURN_FAIL;
2119                         }
2120                         break;
2121                 default:
2122                         SETTING_TRACE_DEBUG("unknown value of min_complex, %d", min_complex);
2123         }
2124         return SETTING_RETURN_SUCCESS;
2125 }
2126
2127 int _is_numeric(const char *str)
2128 {
2129         SETTING_TRACE_BEGIN;
2130         int length = strlen(str);
2131         int index = 0;
2132         char temp = 0;
2133
2134         if(length <= 0)
2135         {
2136                 SETTING_TRACE_DEBUG("[DEBUG] invalid input length");
2137                 return SETTING_RETURN_FAIL;
2138         }
2139         for(index = 0; index < length; index++)
2140         {
2141                 temp = (char)(str[index]);
2142                 if((temp < '0') || ( temp > '9'))
2143                 {
2144                         SETTING_TRACE_DEBUG("[DEBUG] %c is not a digit", temp);
2145                         return SETTING_RETURN_FAIL;
2146                 }
2147                 else
2148                         SETTING_TRACE_DEBUG("temp %c", temp);
2149         }
2150         return SETTING_RETURN_SUCCESS;
2151 }
2152
2153 static int setting_password_main_match_with_mdm_policy(const char* input, mdm_password_policy_t *policy)
2154 {
2155         retv_if(input == NULL || policy == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2156
2157         int letter = 0;
2158         int digit = 0;
2159         int symbol = 0;
2160         int length = strlen(input);
2161         int ret = 0;
2162
2163         if(_count_string(input, &letter, &digit, &symbol) != SETTING_RETURN_SUCCESS)
2164                 return SETTING_RETURN_FAIL;
2165
2166         if(letter < 1)  /* should include 1 letter at least. */
2167                 return SETTING_PW_ERROR_INCLUDE_NO_LETTER;
2168
2169         ret = _check_min_length(length, policy->min_length);
2170         if(ret != SETTING_RETURN_SUCCESS)
2171         {
2172                 SETTING_TRACE_DEBUG("[ERROR] _check_min_length(): invalid return %d", ret);
2173                 return SETTING_PW_ERROR_INVALID_LENGTH;
2174         }
2175
2176         if(policy->quality == MDM_PASSWORD_QUALITY_ALPHANUMERIC)
2177         {
2178                 ret = _check_min_complex(policy->min_complex, digit, symbol);
2179                 if(ret != SETTING_RETURN_SUCCESS)
2180                 {
2181                         SETTING_TRACE_DEBUG("[ERROR] _check_min_complex(): invalid return %d", ret);
2182                         return SETTING_PW_ERROR_NO_MATCH_MIN_COMPLEX;
2183                 }
2184         }
2185
2186         // check pattern
2187         int cflags = REG_EXTENDED;
2188         int eflags = 0;
2189         int match_len = 0;
2190         regex_t reg;
2191         regmatch_t pmatch;
2192
2193         if((policy->pattern != NULL) && (strlen(policy->pattern) > 0))
2194         {
2195                 ret = regcomp(&reg, policy->pattern, cflags);
2196                 if(ret != 0)
2197                 {
2198                         SETTING_TRACE_DEBUG("[DEBUG] fail to compile pattern");
2199                         return SETTING_RETURN_FAIL;
2200                 }
2201                 ret = regexec(&reg, policy->pattern, 1, &pmatch, eflags);
2202                 if(ret != 0)
2203                 {
2204                         SETTING_TRACE_DEBUG("[DEBUG] input does not match with pattern");
2205                         return SETTING_RETURN_FAIL;
2206                 }
2207                 match_len = pmatch.rm_eo - pmatch.rm_so;
2208                 if((pmatch.rm_so != 0) || (match_len != strlen(policy->pattern)))
2209                 {
2210                         SETTING_TRACE_DEBUG("[DEBUG] input does not match with pattern");
2211                         return SETTING_RETURN_FAIL;
2212                 }
2213                 regfree(&reg);
2214         }
2215
2216         // 3. no need to check max_num_wipe, expire time, and history count
2217
2218         return SETTING_RETURN_SUCCESS;
2219 }
2220 #endif
2221
2222 static int setting_password_main_check_2line_password(void *data)
2223 {
2224         /* error check */
2225         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2226
2227         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2228
2229         const char *entry_str1 = ad->ed_pw1->sub_desc;
2230         const char *entry_str2 = ad->ed_pw2->sub_desc;
2231         ad->focus_data = ad->ed_pw1;
2232
2233         /*  Empty Check */
2234         if (isEmptyStr(entry_str1)) {
2235 #ifdef SUPPORT_POPUP
2236                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2237 #else
2238                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2239 #endif
2240                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
2241         }
2242
2243         if (isEmptyStr(entry_str2)) {
2244                 ad->focus_data = ad->ed_pw2;
2245 #ifdef SUPPORT_POPUP
2246                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2247 #else
2248                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2249 #endif
2250                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
2251         }
2252
2253         /*  Length Check */
2254         int entry_str_len = safeStrLen(entry_str1);
2255         switch (ad->view_type) {
2256         case SETTING_PW_TYPE_SET_PASSWORD:
2257                 {
2258                         if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
2259                             || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH)
2260                         {
2261                                 setting_password_main_warning_entry_added_byte_popup
2262                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2263                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2264                         }
2265                 }
2266                 break;
2267
2268         case SETTING_PW_TYPE_SIM_LOCK_ON:
2269                 {
2270                         if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
2271                             || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH) {
2272                                 setting_password_main_warning_entry_added_byte_popup
2273                                         (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
2274                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2275                         }
2276                 }
2277                 break;
2278         default:
2279                 break;
2280         }
2281
2282         /*  Match Check */
2283         if (0 != safeStrCmp(entry_str1, entry_str2)) {
2284 #ifdef SUPPORT_POPUP
2285                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
2286 #else
2287                 setting_password_ug_display_desc(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
2288 #endif
2289                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
2290         }
2291
2292 #ifdef SUPPORT_MDM
2293         if(ad->view_type == SETTING_PW_TYPE_SET_PASSWORD)
2294         {
2295                 int letter = 0;
2296                 int digit = 0;
2297                 int symbol = 0;
2298
2299                 if( _count_string(entry_str1, &letter, &digit, &symbol) == SETTING_RETURN_SUCCESS)
2300                 {
2301                         if(letter < 1)
2302                                 return SETTING_PW_ERROR_INCLUDE_NO_LETTER;
2303                 }
2304         }
2305 #endif
2306
2307 #ifdef SUPPORT_MDM
2308         if(ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
2309         {
2310                 int ret = 0;
2311                 ret = setting_password_main_match_with_mdm_policy(entry_str1, ad->mdm_policy);
2312                 if(ret == SETTING_RETURN_FAIL)
2313                         return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
2314         }
2315 #endif
2316         return SETTING_RETURN_SUCCESS;
2317 }
2318
2319 static void
2320 setting_password_main_warning_entry_added_byte_popup(SettingPasswordUG *ad,
2321                                                      int min, int max)
2322 {
2323         char str[MAX_SPECIALIZITION_LEN + 1] = { 0 };
2324
2325         snprintf(str, MAX_SPECIALIZITION_LEN, "%d~%d %s", min, max, _("characters required"));
2326
2327         /* SETTING_TRACE("str:%s", str); */
2328 #ifdef SUPPORT_POPUP
2329         setting_password_ug_create_popup_notitle_nobtn(ad, str, FALSE);
2330 #else
2331         setting_password_ug_display_desc(ad, str, FALSE);
2332 #endif
2333 }
2334
2335 static int setting_password_main_check_3line_password(void *data)
2336 {
2337         /* error check */
2338         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2339
2340         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2341
2342         const char *entry_str1 = ad->ed_pw1->sub_desc;
2343         const char *entry_str2 = ad->ed_pw2->sub_desc;
2344         const char *entry_str3 = ad->ed_pw3->sub_desc;
2345         ad->focus_data = ad->ed_pw1;
2346
2347         /*  Empty Check */
2348         if (isEmptyStr(entry_str1)) {
2349 #ifdef SUPPORT_POPUP
2350                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2351 #else
2352                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2353 #endif
2354                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
2355         }
2356
2357         if (isEmptyStr(entry_str2)) {
2358                 ad->focus_data = ad->ed_pw2;
2359 #ifdef SUPPORT_POPUP
2360                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2361 #else
2362                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2363 #endif
2364                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
2365         }
2366
2367         if (isEmptyStr(entry_str3)) {
2368                 ad->focus_data = ad->ed_pw3;
2369 #ifdef SUPPORT_POPUP
2370                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2371 #else
2372                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
2373 #endif
2374                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
2375         }
2376
2377         /*  Length Check */
2378         int entry_str1_len = safeStrLen(entry_str1);
2379         int entry_str2_len = safeStrLen(entry_str2);
2380         int entry_str3_len = safeStrLen(entry_str3);
2381         switch (ad->view_type) {
2382         case SETTING_PW_TYPE_CHANGE_PASSWORD:
2383         {
2384                                 if (entry_str1_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
2385                                 || entry_str1_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
2386                         setting_password_main_warning_entry_added_byte_popup
2387                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2388                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2389                 }
2390                                 if (entry_str2_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
2391                                 || entry_str2_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
2392                         ad->focus_data = ad->ed_pw2;
2393                         setting_password_main_warning_entry_added_byte_popup
2394                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2395                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2396                 }
2397                                 if (entry_str3_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
2398                                 || entry_str3_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
2399                         ad->focus_data = ad->ed_pw3;
2400                         setting_password_main_warning_entry_added_byte_popup
2401                                         (ad, SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH, SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
2402                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2403                 }
2404         }
2405                 break;
2406
2407         case SETTING_PW_TYPE_PIN1_BLOCKED:
2408         case SETTING_PW_TYPE_PIN2_BLOCKED:
2409         case SETTING_PW_TYPE_CHANGE_PIN1:
2410         case SETTING_PW_TYPE_CHANGE_PIN2:
2411                 {
2412                         if (entry_str1_len < SETTING_PW_UG_PIN_MIN_LENGTH
2413                             || entry_str1_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2414                                 setting_password_main_warning_entry_added_byte_popup
2415                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2416                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2417                         }
2418                         if (entry_str2_len < SETTING_PW_UG_PIN_MIN_LENGTH
2419                             || entry_str2_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2420                                 ad->focus_data = ad->ed_pw2;
2421                                 setting_password_main_warning_entry_added_byte_popup
2422                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2423                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2424                         }
2425                         if (entry_str3_len < SETTING_PW_UG_PIN_MIN_LENGTH
2426                             || entry_str3_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
2427                                 ad->focus_data = ad->ed_pw3;
2428                                 setting_password_main_warning_entry_added_byte_popup
2429                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
2430                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
2431                         }
2432                 }
2433                 break;
2434         default:
2435                 break;
2436         }
2437
2438         /*  Match Check */
2439         if (0 != safeStrCmp(entry_str2, entry_str3)) {
2440                 ad->focus_data = ad->ed_pw2;
2441 #ifdef SUPPORT_POPUP
2442                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
2443 #else
2444                 setting_password_ug_display_desc(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
2445 #endif
2446                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
2447         }
2448
2449 #ifdef SUPPORT_MDM
2450         if(ad->view_type == SETTING_PW_TYPE_CHANGE_PASSWORD)
2451         {
2452                 int letter = 0;
2453                 int digit = 0;
2454                 int symbol = 0;
2455
2456                 if( _count_string(entry_str2, &letter, &digit, &symbol) == SETTING_RETURN_SUCCESS)
2457                 {
2458                         if(letter < 1)
2459                                 return SETTING_PW_ERROR_INCLUDE_NO_LETTER;
2460                 }
2461         }
2462 #endif
2463
2464         return SETTING_RETURN_SUCCESS;
2465 }
2466
2467 static void
2468 setting_password_main_click_softkey_cancel_cb(void *data, Evas_Object *obj,
2469                                               void *event_info)
2470 {
2471         /* error check */
2472         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
2473
2474         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2475
2476         if(ad->sp_entry4)
2477         {
2478                 /*  add this below for removing IMF faster */
2479                 /*  need to discuss with IMF or Entry developer more */
2480                 elm_object_focus_set(ad->sp_entry4, EINA_FALSE);
2481                 /* end */
2482         }
2483
2484         /* send result : Cancel */
2485         service_h svc;
2486         if(service_create(&svc))
2487                 return;
2488
2489         service_add_extra_data(svc, "result", "Cancel");
2490         ug_send_result(ad->ug, svc);
2491         SETTING_TRACE("Send Result : %s\n", "Cancel");
2492
2493         service_destroy(svc);
2494
2495         /* Send destroy request */
2496         ug_destroy_me(ad->ug);
2497
2498 }
2499
2500 static void
2501 setting_password_main_click_softkey_done_cb(void *data, Evas_Object *obj,
2502                                             void *event_info)
2503 {
2504         /* error check */
2505         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
2506
2507         int err = 0;
2508         int ret = 0;
2509         char svalue[SHA256_DIGEST_LENGTH] = { 0, };
2510
2511         memset(svalue, 0x0, SHA256_DIGEST_LENGTH);
2512
2513         SettingPasswordUG *ad = (SettingPasswordUG *) data;
2514         service_h svc;
2515         if (service_create(&svc))
2516                 return;
2517
2518         SETTING_TRACE("ad->view_type:%d", ad->view_type);
2519
2520         switch (ad->view_type) {
2521                 case SETTING_PW_TYPE_PASSWORD:
2522                         ret = setting_password_main_check_1line_password(ad);
2523
2524                         if (ret == SETTING_RETURN_SUCCESS) {
2525                                 const char *entry_str;
2526                                 entry_str = ad->ed_pw1->sub_desc;
2527
2528                                 ret = setting_password_check_password(entry_str, NULL, NULL);
2529                                 if(ret == SETTING_RETURN_SUCCESS)
2530                                 {
2531                                         int err;
2532
2533                                         if(safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PASSWORD") == 0) {
2534
2535                                                 /*  reset VCONF */
2536                                                 setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,
2537                                                                                         PHONE_LOCK_ATTEMPS_MAX, &err);
2538                                                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
2539                                         }
2540                                         else if(0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_ENTER_LOCK_TYPE"))
2541                                         {
2542                                                 service_add_extra_data(svc, "current", entry_str);
2543                                         }
2544                                 } else {
2545                                         /*  Incorrect Password. Display Popup.   */
2546                                         setting_password_main_clear_1line_password(ad);
2547                                         ad->focus_data = ad->ed_pw1;
2548                                         if (safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PASSWORD") == 0) {
2549                                                 setting_password_ug_check_attemps_left(ad);
2550                                                 return;
2551                                         }
2552 #ifdef SUPPORT_POPUP
2553                                         setting_password_ug_create_popup_notitle_nobtn(ad,
2554                                                                                         _("IDS_COM_POP_INCORRECT_PASSWORD"), FALSE);
2555 #else
2556                                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2557 #endif
2558                                         if(safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_RESET") == 0)
2559                                         {
2560                                                 service_add_extra_data(svc, "result", "Fail");
2561                                                 ug_send_result(ad->ug, svc);
2562                                                 SETTING_TRACE("Send Result : %s\n", "Fail");
2563
2564                                                 service_destroy(svc);
2565                                                 /* Send destroy request */
2566                                                 ug_destroy_me(ad->ug);
2567                                         }
2568                                         return;
2569                                 }
2570                         } else {
2571                                 setting_password_main_clear_1line_password(ad);
2572                                 return;
2573                         }
2574                         break;
2575
2576 #ifdef SUPPORT_MDM
2577                 case SETTING_PW_TYPE_MDM_NEW_POLICY:
2578                         SETTING_TRACE("case SETTING_PW_TYPE_MDM_NEW_POLICY");
2579                         ret = setting_password_main_check_2line_password(ad);
2580
2581                         if (SETTING_RETURN_SUCCESS == ret)
2582                         {
2583                                 const char *entry_str;
2584                                 entry_str = ad->ed_pw1->sub_desc;
2585
2586                                 if (isEmptyStr(entry_str)) {
2587                                         ad->focus_data = ad->ed_pw1;
2588                                         SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get return NULL ***%s",
2589                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2590                                         return;
2591                                 }
2592
2593                                 if(ad->step1_str)
2594                                         ret = setting_password_set_password(ad->step1_str, entry_str, ad);
2595                                 else
2596                                         ret = setting_password_set_password(NULL, entry_str, ad);
2597
2598                                 if(ret == SETTING_RETURN_SUCCESS)
2599                                 {
2600                                         FREE(ad->step1_str);
2601
2602                                         SETTING_TRACE_DEBUG("[DEBUG] success to set password");
2603
2604                                         /* To Do : 1. phone lock on */
2605                                         /*         2. if quality is something, simple password on.*/
2606                                         /*         3. else, simple password off */
2607                                         setting_set_bool_slp_key(BOOL_SLP_SETTING_POWER_ON_LOCK,
2608                                                                                                 SETTING_ON_OFF_BTN_ON, &err);
2609                                         setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
2610
2611                                         setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,
2612                                                                                 ad->mdm_policy->max_num_wipe, &err);
2613                                         setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
2614
2615                                         vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, FALSE);
2616
2617                                         /* End */
2618
2619                                         SETTING_TRACE_DEBUG("[DEBUG] send status to mdm");
2620                                         mdm_set_password_status(MDM_PASSWORD_CHANGED);
2621                                         setting_password_ug_create_popup_notitle_nobtn(ad,
2622                                                                                 _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
2623                                 }
2624                                 else if(ret == SECURITY_SERVER_API_ERROR_PASSWORD_REUSED)
2625                                 {
2626                                         setting_password_ug_display_mdm_desc(ad, PASSWORD_MUST_NOT_MATCH_PREV);
2627                                         return;
2628                                 }
2629                                 else
2630                                 {
2631                                         setting_password_ug_display_mdm_desc(ad, ENTER_ANOTHER_PASSWORD);
2632                                         setting_password_main_clear_2line_password(ad);
2633                                         return;
2634                                 }
2635                         }
2636                         else
2637                         {
2638                                 setting_password_ug_display_mdm_desc(ad, ENTER_ANOTHER_PASSWORD);
2639                                 setting_password_main_clear_2line_password(ad);
2640                                 return;
2641                         }
2642                         break;
2643 #endif
2644                 case SETTING_PW_TYPE_SET_PASSWORD:
2645                         {
2646                                 SETTING_TRACE("case SETTING_PW_TYPE_SET_PASSWORD");
2647                                 ret = setting_password_main_check_2line_password(ad);
2648
2649                                 if (SETTING_RETURN_SUCCESS == ret) {
2650                                         const char *entry_str;
2651                                         entry_str = ad->ed_pw1->sub_desc;
2652
2653                                         if (isEmptyStr(entry_str)) {
2654                                                 ad->focus_data = ad->ed_pw1;
2655                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get return NULL ***%s",
2656                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2657                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2658                                                 return;
2659                                         }
2660
2661                                         ret = setting_password_set_password(ad->cur_pwd, entry_str,ad);
2662
2663                                         /*  Modify Setting Password */
2664                                         if (SETTING_RETURN_FAIL != ret) {
2665                                                 /*  Display popup */
2666                                                 service_add_extra_data(svc, "current", entry_str);
2667                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_NEW_PASSWD_SAVED"), TRUE);
2668                                         } else {
2669                                                 ad->focus_data = ad->ed_pw1;
2670                                                 /*  Error Msg */
2671                                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
2672                                                                                 SETTING_FONT_RED, err, SETTING_FONT_BLACK);
2673                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2674                                                 return;
2675                                         }
2676                                 } else {
2677                                         setting_password_main_clear_2line_password(ad);
2678                                         return;
2679                                 }
2680                         }
2681                         break;
2682 #ifdef SUPPORT_MDM
2683                 case SETTING_PW_TYPE_MDM_CHANGE_PASSWORD:
2684                 {
2685                         SETTING_TRACE_DEBUG("case MDM_CHANGE_PASSWORD_STEP1");
2686                         ad->step1_str = strdup(ad->ed_pw1->sub_desc);
2687                         SETTING_TRACE_DEBUG("step1_str : %s", ad->step1_str);
2688
2689                         unsigned int remain_attempt = ATTEMPT_INFINITE;
2690                         unsigned int valid_seconds = 0;
2691                         char guide_text[DESC_BUF1_SIZE] = {0,};
2692
2693                         if(ad->step1_str == NULL)
2694                         {
2695                                 SETTING_TRACE_DEBUG("step1_str is NULL");
2696                         }
2697                         else
2698                         {
2699                                 ret = setting_password_check_password(ad->step1_str, &remain_attempt, &valid_seconds);
2700                                 // check current password
2701                                 if(ret != SETTING_RETURN_SUCCESS){
2702                                         setting_password_main_clear_1line_password(ad);
2703                                         ad->focus_data = ad->ed_pw1;
2704                                         FREE(ad->step1_str);
2705
2706                                         if(valid_seconds == 0)
2707                                         {
2708                                                 mdm_set_password_status(MDM_PASSWORD_EXPIRED);
2709                                                 setting_password_ug_display_mdm_desc(ad, PASSWORD_EXPIRED);
2710                                                 return;
2711                                         }
2712
2713                                         if((remain_attempt > 0) && (ad->mdm_policy->recoverable == TRUE))
2714                                         {
2715                                                 // display guide text. remain_attempt with recovery mode
2716                                                 char temp[DESC_BUF1_SIZE] = {0,};
2717                                                 snprintf(temp, sizeof(temp), ATTEMPTS_DESC, remain_attempt);
2718                                                 snprintf(guide_text, sizeof(guide_text), "%s. %s.", PW_ERR_DESC, temp);
2719                                                 setting_password_ug_display_mdm_desc(ad, guide_text);
2720                                         }
2721                                         else if((remain_attempt > 0) && (ad->mdm_policy->recoverable == FALSE))
2722                                         {
2723                                                 // display guide text. remain_attempt with wipe mode
2724                                                 char temp[DESC_BUF1_SIZE] = {0,};
2725                                                 snprintf(temp, sizeof(temp), ATTEMPTS_DESC, remain_attempt);
2726                                                 snprintf(guide_text, sizeof(guide_text), "%s. %s.", PW_ERR_DESC, temp);
2727                                                 setting_password_ug_display_mdm_desc(ad, guide_text);
2728                                         }
2729                                         else if((remain_attempt == 0) && (ad->mdm_policy->recoverable == TRUE))
2730                                         {
2731                                                 mdm_set_password_status(MDM_PASSWORD_FAILED);
2732                                                 setting_password_ug_display_mdm_desc(ad, MAX_NUM_REACHED);
2733                                         }
2734                                         else if((remain_attempt == 0) && (ad->mdm_policy->recoverable == FALSE))
2735                                         {
2736                                                 mdm_set_password_status(MDM_RECOVERY_PASSWORD_FAILED);
2737                                                 setting_password_ug_display_mdm_desc(ad, MAX_NUM_REACHED);
2738                                         }
2739                                         return;
2740                                 }
2741                                 SETTING_TRACE_DEBUG("Success to check step1_str");
2742
2743                                 elm_genlist_clear(ad->scroller);
2744                                 if(((ad->mdm_policy->quality == MDM_PASSWORD_QUALITY_SOMETHING)
2745                                         || (ad->mdm_policy->quality == MDM_PASSWORD_QUALITY_NUMERIC)))
2746                                 {
2747                                         if(ad->mdm_policy->min_length <= SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH)
2748                                         {
2749                                                 ad->view_type = SETTING_PW_TYPE_MDM_TO_SIMPLE;
2750                                                 __create_common_password_frame(ad);
2751                                                 setting_password_main_draw_simple_password(ad, 1);
2752                                         }
2753                                         else
2754                                         {
2755                                                 ad->view_type = SETTING_PW_TYPE_MDM_NEW_POLICY;
2756                                                 setting_password_main_draw_2line_password(ad, NULL);
2757                                         }
2758                                 }
2759                                 else if(ad->mdm_policy->quality == MDM_PASSWORD_QUALITY_UNSPECIFIED)
2760                                 {
2761                                         ad->view_type = SETTING_PW_TYPE_MDM_TO_SIMPLE;
2762                                         __create_common_password_frame(ad);
2763                                         setting_password_main_draw_simple_password(ad, 1);
2764                                 }
2765                                 else
2766                                 {
2767                                         ad->view_type = SETTING_PW_TYPE_MDM_NEW_POLICY;
2768                                         setting_password_main_draw_2line_password(ad, NULL);
2769                                 }
2770                         }
2771                 }
2772                 break;
2773 #endif
2774                 case SETTING_PW_TYPE_CHANGE_PASSWORD:
2775                         {
2776                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PASSWORD");
2777                                 ret = setting_password_main_check_3line_password(ad);
2778
2779                                 if (SETTING_RETURN_SUCCESS == ret) {
2780                                         const char *entry_str;
2781 #if LEGACY
2782                                         entry_str = ad->ed_pw1->sub_desc;
2783
2784                                         ret = setting_password_check_password(entry_str, NULL, NULL);
2785
2786                                         if(ret != SETTING_RETURN_SUCCESS){
2787                                                 setting_password_main_clear_3line_password(ad);
2788                                                 ad->focus_data = ad->ed_pw1;
2789
2790 #ifdef SUPPORT_POPUP
2791                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_INCORRECT_PASSWORD"), FALSE);
2792 #else
2793                                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2794 #endif
2795                                                 return;
2796                                         }
2797 #endif
2798
2799                                         entry_str = ad->ed_pw2->sub_desc;
2800
2801                                         if (isEmptyStr(entry_str)) {
2802                                                 ad->focus_data = ad->ed_pw2;
2803                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get(pw2) return NULL ***%s",
2804                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
2805                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2806                                                 return;
2807                                         }
2808
2809 #ifdef SUPPORT_MDM
2810                                         if(ad->mdm_data != NULL)
2811                                         {
2812                                                 ad->mdm_policy = (mdm_password_policy_t*)(ad->mdm_data->data);
2813
2814                                                 if(ad->mdm_policy->quality != MDM_PASSWORD_QUALITY_UNSPECIFIED)
2815                                                 {
2816                                                         SETTING_TRACE_DEBUG("checking policy");
2817                                                         ret = setting_password_main_match_with_mdm_policy(entry_str, ad->mdm_policy);
2818                                                         if(ret != SETTING_RETURN_SUCCESS)
2819                                                         {
2820                                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2821                                                                 return;
2822                                                         }
2823                                                 }
2824                                         }
2825 #endif
2826
2827                                         ret = setting_password_set_password(ad->ed_pw1->sub_desc, entry_str, ad);
2828
2829                                         /*  Modify Setting Password */
2830                                         if (SETTING_RETURN_FAIL != ret) {
2831                                                 /*  Display popup */
2832                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PASSWORD_CHANGED"), TRUE);
2833                                         } else {
2834                                                 ad->focus_data = ad->ed_pw2;
2835                                                 /*  Error Msg */
2836                                                 SETTING_TRACE_DEBUG("%s*** [ERR] setting_set_string_slp_key err=%d ***%s",
2837                                                                                 SETTING_FONT_RED, err, SETTING_FONT_BLACK);
2838                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2839                                                 return;
2840                                         }
2841
2842                                 } else {
2843                                         setting_password_main_clear_3line_password(ad);
2844                                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2845                                         return;
2846                                 }
2847                         }
2848                         break;
2849
2850                 case SETTING_PW_TYPE_PIN_LOCK_ON:
2851                         {
2852                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_ON");
2853
2854                                 ret = setting_password_main_check_1line_password(ad);
2855                                 if (ret == SETTING_RETURN_SUCCESS) {
2856                                         TelSimFacilityPw_t sim_sec_data = { 0, };
2857                                         int tapi_ret = TAPI_API_SUCCESS;
2858                                         const char *entry_str;
2859
2860                                         entry_str = ad->ed_pw1->sub_desc;
2861                                         if (isEmptyStr(entry_str)) {
2862                                                 ad->focus_data = ad->ed_pw1;
2863                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
2864                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2865                                                 return;
2866                                         }
2867
2868                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_SC;//TAPI_SIM_PTYPE_PIN1;
2869                                         sim_sec_data.pw = (unsigned char *)entry_str;
2870                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2871
2872                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
2873                                         setting_password_main_clear_1line_password(ad);
2874
2875                                         if (TAPI_API_SUCCESS != tapi_ret) {
2876                                                 ad->focus_data = ad->ed_pw1;
2877                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_enable_sim_facility err=%d ***%s",
2878                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2879                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2880                                         } else {
2881                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2882                                                 SETTING_TRACE_DEBUG("*** [SUCCESS] tel_enable_sim_facility err=%d ***", tapi_ret);
2883                                         }
2884                                 } else {
2885                                         setting_password_main_clear_1line_password(ad);
2886                                 }
2887                         }
2888                         return;
2889                 case SETTING_PW_TYPE_PIN_LOCK_OFF:
2890                         {
2891                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_OFF");
2892
2893                                 ret = setting_password_main_check_1line_password(ad);
2894
2895                                 if (ret == SETTING_RETURN_SUCCESS) {
2896                                         TelSimFacilityPw_t sim_sec_data = { 0, };
2897                                         int tapi_ret = TAPI_API_SUCCESS;
2898                                         const char *entry_str;
2899
2900                                         entry_str = ad->ed_pw1->sub_desc;
2901                                         if (isEmptyStr(entry_str)) {
2902                                                 ad->focus_data = ad->ed_pw1;
2903                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
2904                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2905                                                 return;
2906                                         }
2907
2908                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_SC;//TAPI_SIM_PTYPE_PIN1
2909                                         sim_sec_data.pw = (unsigned char *)entry_str;
2910                                         sim_sec_data.pw_len = safeStrLen(entry_str);
2911
2912                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
2913                                         setting_password_main_clear_1line_password(ad);
2914
2915                                         if (TAPI_API_SUCCESS != tapi_ret) {
2916                                                 ad->focus_data = ad->ed_pw1;
2917                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_facility err=%d ***%s",
2918                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2919                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2920                                         } else {
2921                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status                                           */
2922                                         }
2923                                 } else {
2924                                         setting_password_main_clear_1line_password(ad);
2925                                 }
2926                         }
2927                         return;
2928                 case SETTING_PW_TYPE_PIN1_BLOCKED:
2929                         {
2930                                 /*  PIN1 Status is "Blocked": User should input puk code and new pin1 code. */
2931                                 /*  If puk code is correct and success to modify pin1 code, display pin1 code change popup */
2932                                 /*  But, if this menu is "Pin Lock", pinlock status will not be changed. */
2933                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN1_BLOCKED");
2934                                 ret = setting_password_main_check_3line_password(ad);
2935
2936                                 if (ret == SETTING_RETURN_SUCCESS) {
2937                                         TelSimSecPw_t puk1_data = { 0, };
2938                                         TelSimSecPw_t pin1_data = { 0, };
2939                                         int tapi_ret = TAPI_API_SUCCESS;
2940                                         const char *puk;
2941                                         const char *new_pin1;
2942
2943                                         puk = ad->ed_pw1->sub_desc;
2944                                         new_pin1 = ad->ed_pw2->sub_desc;
2945                                         if (isEmptyStr(puk)) {
2946                                                 ad->focus_data = ad->ed_pw1;
2947                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2948                                                 return;
2949                                         }
2950
2951                                         if (isEmptyStr(new_pin1)) {
2952                                                 ad->focus_data = ad->ed_pw2;
2953                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2954                                                 return;
2955                                         }
2956
2957                                         puk1_data.type = TAPI_SIM_PTYPE_PUK1;
2958                                         puk1_data.pw = (unsigned char *)puk;
2959                                         puk1_data.pw_len = safeStrLen(puk);
2960
2961                                         pin1_data.type = TAPI_SIM_PTYPE_PIN1;
2962                                         pin1_data.pw = (unsigned char *)new_pin1;
2963                                         pin1_data.pw_len = safeStrLen(new_pin1);
2964
2965                                         tapi_ret = tel_verify_sim_puks(ad->handle, &puk1_data, &pin1_data, setting_sim_verify_puks_cb, ad);
2966                                         setting_password_main_clear_3line_password(ad);
2967
2968                                         if (TAPI_API_SUCCESS != tapi_ret) {
2969                                                 ad->focus_data = ad->ed_pw1;
2970                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
2971                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
2972                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2973                                         } else {
2974                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
2975
2976                                         }
2977                                 } else {
2978                                         setting_password_main_clear_3line_password(ad);
2979                                 }
2980                         }
2981                         return;
2982                 case SETTING_PW_TYPE_PIN2_BLOCKED:
2983                         {
2984                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN2_BLOCKED");
2985                                 ret = setting_password_main_check_3line_password(ad);
2986
2987                                 if (ret == SETTING_RETURN_SUCCESS) {
2988                                         TelSimSecPw_t puk2_data = { 0, };
2989                                         TelSimSecPw_t pin2_data = { 0, };
2990                                         int tapi_ret = TAPI_API_SUCCESS;
2991                                         const char *puk;
2992                                         const char *new_pin2;
2993
2994                                         puk = ad->ed_pw1->sub_desc;
2995                                         new_pin2 = ad->ed_pw2->sub_desc;
2996                                         if (isEmptyStr(puk)) {
2997                                                 ad->focus_data = ad->ed_pw1;
2998                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
2999                                                 return;
3000                                         }
3001
3002                                         if (isEmptyStr(new_pin2)) {
3003                                                 ad->focus_data = ad->ed_pw2;
3004                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3005                                                 return;
3006                                         }
3007
3008                                         puk2_data.type = TAPI_SIM_PTYPE_PUK2;
3009                                         puk2_data.pw = (unsigned char *)puk;
3010                                         puk2_data.pw_len = safeStrLen(puk);
3011
3012                                         pin2_data.type = TAPI_SIM_PTYPE_PIN2;
3013                                         pin2_data.pw = (unsigned char *)new_pin2;
3014                                         pin2_data.pw_len = safeStrLen(new_pin2);
3015
3016                                         tapi_ret = tel_verify_sim_puks(ad->handle, &puk2_data, &pin2_data, setting_sim_verify_puks_cb, ad);
3017                                         setting_password_main_clear_3line_password(ad);
3018
3019                                         if (TAPI_API_SUCCESS != tapi_ret) {
3020                                                 ad->focus_data = ad->ed_pw1;
3021                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
3022                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
3023                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3024                                         } else {
3025                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
3026
3027                                         }
3028                                 } else {
3029                                         setting_password_main_clear_3line_password(ad);
3030                                 }
3031                         }
3032                         return;
3033                 case SETTING_PW_TYPE_CHANGE_PIN1:
3034                         {
3035                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN1");
3036
3037                                 ret = setting_password_main_check_3line_password(ad);
3038                                 if (ret == SETTING_RETURN_SUCCESS) {
3039                                         const char *old_pw;
3040                                         const char *new_pw;
3041                                         TelSimSecPw_t sim_old_sec_data = { 0, };
3042                                         TelSimSecPw_t sim_new_sec_data = { 0, };
3043                                         int tapi_ret = TAPI_API_SUCCESS;
3044
3045                                         old_pw = ad->ed_pw1->sub_desc;
3046                                         new_pw = ad->ed_pw2->sub_desc;
3047                                         if (isEmptyStr(old_pw)) {
3048                                                 ad->focus_data = ad->ed_pw1;
3049                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3050                                                 return;
3051                                         }
3052
3053                                         if (isEmptyStr(new_pw)) {
3054                                                 ad->focus_data = ad->ed_pw2;
3055                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3056                                                 return;
3057                                         }
3058
3059                                         sim_old_sec_data.type = sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN1;
3060                                         sim_old_sec_data.pw = (unsigned char *)old_pw;
3061                                         sim_old_sec_data.pw_len = safeStrLen(old_pw);
3062                                         sim_new_sec_data.pw = (unsigned char *)new_pw;
3063                                         sim_new_sec_data.pw_len = safeStrLen(new_pw);
3064
3065                                         tapi_ret = tel_change_sim_pins(ad->handle, &sim_old_sec_data, &sim_new_sec_data, setting_sim_change_pins_cb, ad);
3066                                         setting_password_main_clear_3line_password(ad);
3067
3068                                         if (TAPI_API_SUCCESS != tapi_ret) {
3069                                                 ad->focus_data = ad->ed_pw1;
3070                                                 SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
3071                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
3072                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3073                                         } else {
3074                                                 /*  Success popup and send message to caller */
3075                                                 /* setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PIN1_CHANGED")); */
3076                                         }
3077                                 } else {
3078                                         setting_password_main_clear_3line_password(ad);
3079                                 }
3080                         }
3081                         return;
3082                 case SETTING_PW_TYPE_CHANGE_PIN2:
3083                         {
3084                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN2");
3085                                 ret = setting_password_main_check_3line_password(ad);
3086                                 if (ret == SETTING_RETURN_SUCCESS) {
3087                                         const char *old_pw;
3088                                         const char *new_pw;
3089                                         TelSimSecPw_t sim_old_sec_data = { 0, };
3090                                         TelSimSecPw_t sim_new_sec_data = { 0, };
3091                                         int tapi_ret = TAPI_API_SUCCESS;
3092
3093                                         old_pw = ad->ed_pw1->sub_desc;
3094                                         new_pw = ad->ed_pw2->sub_desc;
3095                                         if (isEmptyStr(old_pw)) {
3096                                                 ad->focus_data = ad->ed_pw1;
3097                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3098                                                 return;
3099                                         }
3100
3101                                         if (isEmptyStr(new_pw)) {
3102                                                 ad->focus_data = ad->ed_pw2;
3103                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3104                                                 return;
3105                                         }
3106
3107                                         sim_old_sec_data.type = sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN2;
3108                                         sim_old_sec_data.pw = (unsigned char *)old_pw;
3109                                         sim_old_sec_data.pw_len = safeStrLen(old_pw);
3110                                         sim_new_sec_data.pw = (unsigned char *)new_pw;
3111                                         sim_new_sec_data.pw_len = safeStrLen(new_pw);
3112
3113                                         tapi_ret = tel_change_sim_pins(ad->handle, &sim_old_sec_data, &sim_new_sec_data, setting_sim_change_pins_cb, ad);
3114                                         setting_password_main_clear_3line_password(ad);
3115
3116                                         if (TAPI_API_SUCCESS != tapi_ret) {
3117                                                 ad->focus_data = ad->ed_pw1;
3118                                                 SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
3119                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
3120                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3121                                         } else {
3122                                                 /*  Success popup and send message to caller */
3123                                                 /* setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PIN2_CHANGED")); */
3124                                         }
3125                                 } else {
3126                                         setting_password_main_clear_3line_password(ad);
3127                                 }
3128                         }
3129                         return;
3130                 case SETTING_PW_TYPE_SIM_LOCK_ON:
3131                         {
3132                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_ON");
3133
3134                                 ret = setting_password_main_check_2line_password(ad);
3135
3136                                 if (ret == SETTING_RETURN_SUCCESS) {
3137                                         TelSimFacilityPw_t sim_sec_data = { 0, };
3138                                         int tapi_ret = TAPI_API_SUCCESS;
3139                                         const char *entry_str;
3140                                         entry_str = ad->ed_pw1->sub_desc;
3141                                         if (isEmptyStr(entry_str)) {
3142                                                 ad->focus_data = ad->ed_pw1;
3143                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3144                                                 return;
3145                                         }
3146
3147                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_PS;//TAPI_SIM_PTYPE_SIM
3148                                         sim_sec_data.pw = (unsigned char *)entry_str;
3149                                         sim_sec_data.pw_len = safeStrLen(entry_str);
3150
3151                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
3152                                         setting_password_main_clear_2line_password(ad);
3153
3154                                         SETTING_TRACE("SIM Lock password : %s\n", (char *)(sim_sec_data.pw));
3155                                         if (TAPI_API_SUCCESS != tapi_ret) {
3156                                                 ad->focus_data = ad->ed_pw1;
3157                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_enable_sim_facility err=%d ***%s",
3158                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
3159                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3160                                         } else {
3161                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
3162
3163                                         }
3164                                 } else {
3165                                         setting_password_main_clear_2line_password(ad);
3166                                 }
3167                         }
3168                         return;
3169                 case SETTING_PW_TYPE_SIM_LOCK_OFF:
3170                         {
3171                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_OFF");
3172
3173                                 ret = setting_password_main_check_1line_password(ad);
3174                                 if (ret == SETTING_RETURN_SUCCESS) {
3175                                         TelSimFacilityPw_t sim_sec_data = { 0, };
3176                                         int tapi_ret = TAPI_API_SUCCESS;
3177                                         const char *entry_str;
3178
3179                                         entry_str = ad->ed_pw1->sub_desc;
3180                                         if (isEmptyStr(entry_str)) {
3181                                                 ad->focus_data = ad->ed_pw1;
3182                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3183                                                 return;
3184                                         }
3185
3186                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_PS;//TAPI_SIM_PTYPE_SIM
3187                                         sim_sec_data.pw = (unsigned char *)entry_str;
3188                                         sim_sec_data.pw_len = safeStrLen(entry_str);
3189
3190                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
3191                                         setting_password_main_clear_1line_password(ad);
3192
3193                                         if (TAPI_API_SUCCESS != tapi_ret) {
3194                                                 ad->focus_data = ad->ed_pw1;
3195                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_facility err=%d ***%s",
3196                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
3197                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3198                                         } else {
3199                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
3200
3201                                         }
3202                                 } else {
3203                                         setting_password_main_clear_1line_password(ad);
3204                                 }
3205                         }
3206                         return;
3207 #if SUPPORT_FDN
3208                 case SETTING_PW_TYPE_FDN_MODE_ON:
3209                         {
3210                                 SETTING_TRACE("case SETTING_PW_TYPE_FDN_MODE_ON");
3211                                 ret = setting_password_main_check_1line_password(ad);
3212
3213                                 if(ret == SETTING_RETURN_SUCCESS)
3214                                 {
3215                                         const char *entry_str;
3216                                         int tapi_ret = TAPI_API_INVALID_INPUT;
3217
3218                                         TelSimFacilityPw_t sim_sec_data = {0,};
3219                                         int ReqId;
3220
3221                                         entry_str = ad->ed_pw1->sub_desc;
3222                                         if(isEmptyStr(entry_str))
3223                                         {
3224                                                 ad->focus_data = ad->ed_pw1;
3225                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
3226                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3227                                                 return;
3228                                         }
3229                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_FD;//TAPI_SIM_PTYPE_PIN2;
3230                                         sim_sec_data.pw_len = safeStrLen(entry_str);
3231                                         sim_sec_data.pw = (unsigned char*)entry_str;
3232
3233                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
3234                                         setting_password_main_clear_1line_password(ad);
3235
3236                                         if(tapi_ret != TAPI_API_SUCCESS)
3237                                         {
3238                                                 ad->focus_data = ad->ed_pw1;
3239                                                 SETTING_TRACE_ERROR("[ERR] Failed to enable FDN. Tapi return %d", tapi_ret);
3240                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3241                                                 return;
3242                                         }
3243
3244                                         /* Success */
3245                                         if (service_create(&svc))
3246                                                 return;
3247
3248                                         service_add_extra_data(svc, "result", ad->view_type_string);
3249                                         ug_send_result(ad->ug, svc);
3250                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
3251                                         service_destroy(svc);
3252                                         //ug_destroy_me(ad->ug);
3253                                 }
3254                                 else
3255                                 {
3256                                         /* check failed */
3257                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), TRUE);
3258                                 }
3259                         }
3260                         break;
3261                 case SETTING_PW_TYPE_FDN_MODE_OFF:
3262                         {
3263                                 SETTING_TRACE("case SETTING_PW_TYPE_FDN_MODE_OFF");
3264                                 ret = setting_password_main_check_1line_password(ad);
3265
3266                                 if(ret == SETTING_RETURN_SUCCESS)
3267                                 {
3268                                         const char *entry_str;
3269                                         int tapi_ret = TAPI_API_INVALID_INPUT;
3270
3271                                         TelSimFacilityPw_t sim_sec_data = {0,};
3272
3273                                         entry_str = ad->ed_pw1->sub_desc;
3274                                         if(isEmptyStr(entry_str))
3275                                         {
3276                                                 ad->focus_data = ad->ed_pw1;
3277                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
3278                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3279                                                 return;
3280                                         }
3281                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_FD;//TAPI_SIM_PTYPE_PIN2
3282                                         sim_sec_data.pw_len = safeStrLen(entry_str);
3283                                         sim_sec_data.pw = (unsigned char*)entry_str;
3284
3285                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
3286                                         setting_password_main_clear_1line_password(ad);
3287
3288                                         if(tapi_ret != TAPI_API_SUCCESS)
3289                                         {
3290                                                 ad->focus_data = ad->ed_pw1;
3291                                                 SETTING_TRACE_ERROR("[ERR] Failed to disable FDN. Tapi return %d", tapi_ret);
3292                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
3293                                                 return;
3294                                         }
3295
3296                                         /* Success */
3297                                         if (service_create(&svc))
3298                                                 return;
3299
3300                                         service_add_extra_data(svc, "result", ad->view_type_string);
3301                                         ug_send_result(ad->ug, svc);
3302                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
3303
3304                                         service_destroy(svc);
3305                                         //ug_destroy_me(ad->ug);
3306                                 }
3307                                 else
3308                                 {
3309                                         /* check failed */
3310                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), TRUE);
3311                                 }
3312                         }
3313                         break;
3314
3315 #endif
3316                 default:
3317                         break;
3318         }
3319
3320         service_add_extra_data(svc, "result", ad->view_type_string);
3321         ug_send_result(ad->ug, svc);
3322         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
3323
3324         service_destroy(svc);
3325         /* Send destroy request */
3326         ug_destroy_me(ad->ug);
3327 }