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 <setting-debug.h>
  26 #include <dd-haptic.h>
  27 #if SUPPORT_ENCRYPTION
  28 #include <ode.h>
  29 #endif
  30 #include <Ecore_IMF.h>
  31 #include <Ecore_IMF_Evas.h>
  32 #include <Ecore.h>
  33 #if SUPPORT_LIBEAS
  34 #include <eas-svc.h>
  35 #endif
  36 #include <time.h>
  37 #include <notification.h>
  38
  39
  40 void __add_help_of_password_fails(int ret, SettingPasswordUG *ad);
  41
  42 static int setting_password_main_create(void *cb);
  43 static int setting_password_main_destroy(void *cb);
  44 static int setting_password_main_update(void *cb);
  45 static int setting_password_main_cleanup(void *cb);
  46
  47
  48 setting_view setting_view_password_main = {
  49         .create = setting_password_main_create,
  50         .destroy = setting_password_main_destroy,
  51         .update = setting_password_main_update,
  52         .cleanup = setting_password_main_cleanup,
  53 };
  54
  55
  56 static void setting_password_main_done_password(void *data);
  57 static int __count_string(const char *str, int *cnt_letter, int *cnt_digit, int *cnt_sym);
  58
  59 extern struct _pw_item pw_its[];
  60
  61 /* ***************************************************
  62  *
  63  *basic func
  64  *
  65  ***************************************************/
  66
  67 static Eina_Bool setting_password_main_click_softkey_cancel_cb(void *data, Elm_Object_Item *it)
  68 {
  69         SETTING_TRACE_BEGIN;
  70         /* error check */
  71         retvm_if(data == NULL, EINA_FALSE, "[Setting > Password] Data parameter is NULL");
  72
  73         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  74
  75         /* if IME is displayed, hide IME. or Destroy password ug. */
  76         elm_object_focus_set(ad->ed_pw1->eo_check, EINA_FALSE);
  77
  78         if (ad->focus_timer) {
  79                 ecore_timer_del(ad->focus_timer);
  80                 ad->focus_timer = NULL;
  81         }
  82
  83         /* send result : Cancel */
  84         app_control_h svc;
  85         if (app_control_create(&svc) == 0) {
  86                 app_control_add_extra_data(svc, "result", "Cancel");
  87                 ug_send_result(ad->ug, svc);
  88                 SETTING_TRACE("Send Result : %s\n", "Cancel");
  89
  90                 app_control_destroy(svc);
  91         }
  92         /* Send destroy request */
  93         ug_destroy_me(ad->ug);
  94
  95         return EINA_TRUE;
  96 }
  97
  98 Eina_Bool __rotate_cb(void *data)
  99 {
 100         /* error check */
 101         SETTING_TRACE_BEGIN;
 102         retv_if(data == NULL, FALSE);
 103
 104         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 105
 106         //SETTING_TRACE_DEBUG("category : 0x%x", pw_its[ad->view_type].category);
 107
 108         /* it can manage the cursor self */
 109         if (ad->ed_pw1 && ad->ed_pw1->eo_check) {
 110                 SETTING_TRACE_DEBUG("set focus on first entry");
 111                 /* no matter how many edifileds, it only need focus on 1st editfiled */
 112                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 113                 elm_entry_cursor_end_set(ad->ed_pw1->eo_check);
 114         }
 115
 116         ad->focus_timer = NULL;
 117
 118         return ECORE_CALLBACK_CANCEL;
 119 }
 120
 121 static int setting_password_main_create(void *cb)
 122 {
 123         SETTING_TRACE_BEGIN;
 124         /* error check */
 125         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 126
 127         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 128
 129         ad->ly_main = setting_create_layout_navi_bar_genlist(ad->win_main_layout, ad->win_get, "IDS_ST_BODY_PASSWORD",
 130                                                              _("IDS_ST_BUTTON_BACK"),
 131                                                              NULL,
 132                                                              (setting_call_back_func)setting_password_main_click_softkey_cancel_cb,
 133                                                              NULL,
 134                                                              ad,
 135                                                              &(ad->scroller),
 136                                                              &(ad->navi_bar));
 137
 138         ad->navi_it = elm_naviframe_top_item_get(ad->navi_bar);
 139
 140         ad->bottom_btn = elm_button_add(ad->navi_bar);
 141         elm_object_style_set(ad->bottom_btn, "bottom");
 142         elm_object_item_part_content_set(ad->navi_it, "toolbar", ad->bottom_btn);
 143
 144         if (ad->view_type == SETTING_PW_TYPE_SET_PASSWORD) {
 145                 elm_object_text_set(ad->bottom_btn, _("IDS_ST_BUTTON_CONTINUE"));
 146                 evas_object_smart_callback_add(ad->bottom_btn, "clicked", setting_password_main_click_softkey_continue_cb, ad);
 147         } else {
 148                 elm_object_text_set(ad->bottom_btn, _("IDS_SA_BUTTON_DONE_ABB"));
 149                 evas_object_smart_callback_add(ad->bottom_btn, "clicked", setting_password_main_click_softkey_done_cb, ad);
 150         }
 151
 152         /*elm_genlist_realization_mode_set(ad->scroller, EINA_FALSE); */
 153         /*elm_genlist_mode_set(ad->scroller, ELM_LIST_COMPRESS); */
 154         ADD_GL_SEPARATOR(ad->scroller)
 155
 156         ad->cur_step = 1;
 157         setting_password_main_draw_1line_password(ad, NULL);
 158
 159         /* Disable Done button if exist */
 160         elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 161         elm_object_focus_allow_set(ad->bottom_btn, EINA_FALSE);
 162
 163         ad->focus_timer = ecore_timer_add(0.5, __rotate_cb, ad);
 164
 165         setting_view_password_main.is_create = 1;
 166
 167         SETTING_TRACE_END;
 168         return SETTING_RETURN_SUCCESS;
 169 }
 170
 171 static int setting_password_main_destroy(void *cb)
 172 {
 173         SETTING_TRACE_BEGIN;
 174         /* error check */
 175         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 176
 177         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 178
 179         FREE(ad->step1_str);
 180
 181         if (ad->remove_timer) {
 182                 ecore_timer_del(ad->remove_timer);
 183                 ad->remove_timer = NULL;
 184         }
 185
 186         if (ad->focus_timer) {
 187                 ecore_timer_del(ad->focus_timer);
 188                 ad->focus_timer = NULL;
 189         }
 190
 191         if (ad->notify) {
 192                 evas_object_del(ad->notify);
 193                 ad->notify = NULL;
 194         }
 195
 196         if (ad->ly_main != NULL) {
 197                 evas_object_del(ad->ly_main);
 198                 ad->ly_main = NULL;
 199         }
 200
 201         setting_view_password_main.is_create = 0;
 202         SETTING_TRACE_END;
 203         return SETTING_RETURN_SUCCESS;
 204 }
 205
 206 static int setting_password_main_update(void *cb)
 207 {
 208         SETTING_TRACE_BEGIN;
 209         /* error check */
 210         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 211
 212         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 213
 214         if (ad->ly_main != NULL) {
 215                 evas_object_show(ad->ly_main);
 216         }
 217         return SETTING_RETURN_SUCCESS;
 218 }
 219
 220 static int setting_password_main_cleanup(void *cb)
 221 {
 222         /* error check */
 223         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 224
 225         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 226
 227         if (ad->ly_main != NULL) {
 228                 evas_object_hide(ad->ly_main);
 229         }
 230
 231         return SETTING_RETURN_SUCCESS;
 232 }
 233
 234 /* ***************************************************
 235  *
 236  *general func
 237  *
 238  ***************************************************/
 239
 240 static void
 241 setting_password_main_entry_changed_cb(void *data, Evas_Object *obj,
 242                                        void *event_info)
 243 {
 244         SETTING_TRACE_BEGIN;
 245         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
 246         retm_if(obj == NULL, "[Setting > Password] Data parameter is NULL");
 247         Setting_GenGroupItem_Data *list_item =
 248             (Setting_GenGroupItem_Data *) data;
 249         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 250         const char *entry_str = elm_entry_entry_get(obj);
 251         list_item->sub_desc = (char *)g_strdup(entry_str);
 252         bool isFoundEmptyEntry = FALSE;
 253
 254         do {
 255                 if (ad->ed_pw1) {
 256                         entry_str = ad->ed_pw1->sub_desc;
 257                         if (NULL == entry_str || '\0' == entry_str[0]) {
 258                                 isFoundEmptyEntry = TRUE;
 259                                 /*char *guide_text = elm_object_part_text_get(obj, "elm.guide"); */
 260                                 /*if(isEmptyStr(guide_text)) */
 261                                 /*{ */
 262                                 /*      SETTING_TRACE("guide is empty"); */
 263                                 /*      elm_object_part_text_set(obj, "elm.guide", _("IDS_ST_BODY_ENTER_PASSWORD")); */
 264                                 /*} */
 265                                 elm_object_item_signal_emit(ad->ed_pw1->item, "elm,state,eraser,hide", "");
 266                                 break;
 267                         } else {
 268                                 /*elm_object_part_text_set(obj, "elm.guide", ""); */
 269                                 elm_object_item_signal_emit(ad->ed_pw1->item, "elm,state,eraser,show", "");
 270                                 break;
 271                         }
 272                 }
 273         } while (0);
 274
 275         Eina_Bool item_disabled = elm_object_item_disabled_get(list_item->item);
 276         if (item_disabled)
 277                 return;
 278
 279         /* For disable toolbar (done) item */
 280         bool disableFlag = isFoundEmptyEntry;
 281         if (ad->ed_pw1 && ad->ed_pw1->eo_check && (safeStrLen(elm_entry_entry_get(ad->ed_pw1->eo_check)) < 4))
 282                 disableFlag = TRUE;
 283
 284 #if SUPPORT_BOTTOM_BTNS
 285         if (disableFlag) {
 286                 elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 287                 elm_entry_input_panel_return_key_disabled_set(obj, EINA_TRUE);
 288         } else {
 289                 elm_object_disabled_set(ad->bottom_btn, EINA_FALSE);
 290                 elm_entry_input_panel_return_key_disabled_set(obj, EINA_FALSE);
 291         }
 292 #else
 293         elm_object_item_disabled_set(elm_toolbar_last_item_get(ad->controllbar), disableFlag);
 294 #endif
 295
 296 }
 297
 298 static void __reached_max_pwlength_cb(void *data, Evas_Object *obj, void *event_info)
 299 {
 300         SETTING_TRACE_BEGIN;
 301         retm_if(data == NULL, "Data parameter is NULL");
 302         retm_if(!elm_object_focus_get(obj), "Entry is not focused");/*notify only when entry is being focused on. */
 303
 304         int err = 0;
 305
 306         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 307         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 308
 309         /* Display help text. */
 310         char temp[128] = {0,};
 311         snprintf(temp, 128, _(PW_ST_PW_MAX_LENGTH_HELP), list_item->limit_filter_data->max_char_count);
 312         setting_password_ug_display_desc(ad, temp, FALSE);
 313 }
 314
 315 static void __entry_activated_cb(void *data, Evas_Object *obj, void *event_info)
 316 {
 317         SETTING_TRACE_BEGIN;
 318         retm_if(data == NULL, "Data parameter is NULL");
 319
 320         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 321         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 322
 323         if (ad->bottom_btn) {
 324                 if (elm_object_disabled_get(ad->bottom_btn) == EINA_FALSE) {
 325                         /* call done cb. */
 326                         if (ad->view_type == SETTING_PW_TYPE_SET_PASSWORD && ad->cur_step == 1) {
 327                                 /* Save first input */
 328                                 ad->step1_str = (char *)strdup(ad->ed_pw1->sub_desc);
 329
 330                                 /* Check step1_str : more than 4, not all digits */
 331                                 int letter = 0;
 332                                 int digit = 0;
 333                                 int symbol = 0;
 334                                 __count_string(ad->step1_str, &letter, &digit, &symbol);
 335                                 if (safeStrLen(ad->step1_str) == digit) {
 336                                         __add_help_of_password_fails(SETTING_PW_ERROR_INCLUDE_NO_LETTER, ad);
 337                                         FREE(ad->step1_str);
 338                                         return;
 339                                 }
 340
 341                                 setting_password_main_clear_1line_password(ad);
 342                                 if (ad->err_desc && ad->err_desc->item) {
 343                                         elm_object_item_del(ad->err_desc->item);
 344                                         ad->err_desc = NULL;
 345                                 }
 346
 347                                 /* Change entry title : PW_SHORT_GUIDE_CONFIRM */
 348                                 FREE(ad->ed_pw1->keyStr);
 349                                 ad->ed_pw1->keyStr = (char *)strdup(PW_SHORT_GUIDE_CONFIRM);
 350                                 elm_genlist_item_fields_update(ad->ed_pw1->item, "elm.text.main", ELM_GENLIST_ITEM_FIELD_TEXT);
 351
 352
 353                                 /* Change button */
 354                                 elm_object_text_set(ad->bottom_btn, _("IDS_SA_BUTTON_DONE_ABB"));
 355                                 evas_object_smart_callback_add(ad->bottom_btn, "clicked", setting_password_main_click_softkey_done_cb, ad);
 356                                 elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 357                                 elm_entry_input_panel_return_key_disabled_set(obj, EINA_TRUE);
 358                                 ad->cur_step++;
 359                         } else {
 360                                 setting_password_main_done_password(ad);
 361                         }
 362                 }
 363         }
 364 }
 365
 366 static void __entry_focused_cb(void *data, Evas_Object *obj, void *event_info)
 367 {
 368         SETTING_TRACE_BEGIN;
 369         retm_if(data == NULL, "Data parameter is NULL");
 370
 371         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 372         SettingPasswordUG *ad = (SettingPasswordUG *)list_item->userdata;
 373
 374         if (!elm_entry_is_empty(obj)) {
 375                 elm_object_item_signal_emit(list_item->item, "elm,state,eraser,show", "");
 376         }
 377         elm_object_item_signal_emit(list_item->item, "elm,state,rename,hide", "");
 378 }
 379
 380 static void __entry_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
 381 {
 382         SETTING_TRACE_BEGIN;
 383         retm_if(data == NULL, "Data parameter is NULL");
 384         retm_if(obj == NULL, "Data parameter is NULL");
 385
 386         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 387
 388         if (list_item->item) {
 389                 elm_object_item_signal_emit(list_item->item, "elm,state,eraser,hide", "");
 390                 elm_object_item_signal_emit(list_item->item, "elm,state,rename,show", "");
 391         }
 392 }
 393
 394 int setting_password_main_draw_1line_password(void *data, void *cb)
 395 {
 396         SETTING_TRACE_BEGIN;
 397         /* error check */
 398         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 399                  "[Setting > Password] Data parameter is NULL");
 400
 401         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 402
 403         switch (ad->view_type) {
 404                 case SETTING_PW_TYPE_PASSWORD:
 405                         ad->ed_pw1 =
 406                             setting_create_Gendial_field_editfield(ad->scroller,
 407                                                                    &(itc_editfield),
 408                                                                    NULL, ad,
 409                                                                    SWALLOW_Type_LAYOUT_EDITFIELD,
 410                                                                    "IDS_ST_BODY_PASSWORD",
 411                                                                    NULL,
 412                                                                    setting_password_main_entry_changed_cb,
 413                                                                    __entry_focused_cb,
 414                                                                    __entry_unfocused_cb,
 415                                                                    __entry_activated_cb,
 416                                                                    __reached_max_pwlength_cb,
 417                                                                    ELM_INPUT_PANEL_LAYOUT_PASSWORD,
 418                                                                    TRUE, TRUE,
 419                                                                    SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
 420                                                                    0, NULL, NULL);
 421                         break;
 422                 case SETTING_PW_TYPE_SET_PASSWORD:
 423                         ad->ed_pw1 =
 424                             setting_create_Gendial_field_editfield(ad->scroller,
 425                                                                    &(itc_editfield),
 426                                                                    NULL, ad,
 427                                                                    SWALLOW_Type_LAYOUT_EDITFIELD,
 428                                                                    PW_SHORT_GUIDE_NEW,
 429                                                                    NULL,
 430                                                                    setting_password_main_entry_changed_cb,
 431                                                                    __entry_focused_cb,
 432                                                                    __entry_unfocused_cb,
 433                                                                    __entry_activated_cb,
 434                                                                    __reached_max_pwlength_cb,
 435                                                                    ELM_INPUT_PANEL_LAYOUT_PASSWORD,
 436                                                                    TRUE, TRUE,
 437                                                                    SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH,
 438                                                                    0, NULL, NULL);
 439
 440                         ad->err_desc = setting_create_Gendial_field_helpitem_without_bottom_separator(
 441                                            ad->scroller,
 442                                            &(itc_multiline_text),
 443                                            SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
 444                                            PW_NORMAL_AND_CONTAIN_ALPHANUMER_DESC);
 445                         break;
 446                 default:
 447                         break;
 448         }
 449
 450         ad->ed_pw2 = NULL;
 451         ad->ed_pw3 = NULL;
 452
 453         return 0;
 454 }
 455
 456 int setting_password_main_clear_1line_password(void *data)
 457 {
 458         /* error check */
 459         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 460                  "[Setting > Password] Data parameter is NULL");
 461
 462         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 463         retv_if(NULL == ad->ed_pw1, -1);
 464
 465         ad->ed_pw1->sub_desc = NULL;
 466         ad->ed_pw1->isFocusFlag = FALSE;
 467
 468         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
 469         elm_object_part_text_set(ad->ed_pw1->eo_check, "elm.guide", _("IDS_ST_BODY_ENTER_PASSWORD"));
 470
 471         return 0;
 472 }
 473
 474 /* This help is shown on entering new/confirm password view */
 475 void __add_help_of_password_policy(SettingPasswordUG *ad)
 476 {
 477         ret_if(ad == NULL);
 478
 479         ad->err_desc = setting_create_Gendial_field_helpitem_without_bottom_separator(
 480                            ad->scroller,
 481                            &(itc_multiline_text),
 482                            SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
 483                            PW_NORMAL_AND_CONTAIN_ALPHANUMER_DESC);
 484
 485         if (ad->ed_pw1 && ad->ed_pw1->eo_check) {
 486                 SETTING_TRACE_DEBUG("FOCUS IN");
 487                 ad->ed_pw1->isFocusFlag = TRUE;
 488                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 489         }
 490 }
 491
 492 /* This help is shown after verifying entered new/confirm password with constraint */
 493 void __add_help_of_password_fails(int ret, SettingPasswordUG *ad)
 494 {
 495         ret_if(ad == NULL);
 496
 497         switch (ret) {
 498                 case SETTING_PW_ERROR_INVALID_LENGTH:
 499                         setting_password_ug_display_desc(ad, "Invalid length", FALSE);
 500                         break;
 501                 case SETTING_PW_ERROR_INCLUDE_NO_LETTER:
 502                         setting_password_ug_display_desc(ad, "IDS_ST_BODY_PASSWORD_MUST_CONTAIN_AT_LEAST_1_LETTER", FALSE);
 503                         break;
 504                 case SETTING_PW_ERROR_NO_MATCH_WITH_POLICY:
 505                         setting_password_ug_display_desc(ad, "No match with policy", FALSE);
 506                         break;
 507                 case SETTING_PW_ERROR_NO_MATCH_MIN_COMPLEX:
 508                         setting_password_ug_display_desc(ad, "No match with min complex", FALSE);
 509                         break;
 510                 case SETTING_PW_ERROR_EXIST_FORBIDDEN_STRING:
 511                         setting_password_ug_display_desc(ad, "Exist forbidden string", FALSE);
 512                         break;
 513                 case SETTING_PW_ERROR_NO_MATCH_MAX_REPEAT_COUNT:
 514                         setting_password_ug_display_desc(ad, "No match with max repeat count", FALSE);
 515                         break;
 516                 case SETTING_PW_ERROR_SIMPLE_STYLE:
 517                         setting_password_ug_display_desc(ad, "Exist simple sequence", FALSE);
 518                         break;
 519                 case SETTING_PW_ERROR_INCLUDE_DIGIT:
 520                         setting_password_ug_display_desc(ad, "Password should not include any digit or symbol", FALSE);
 521                         break;
 522                 case SETTING_PW_ERROR_NO_MATCH_WITH_PATTERN:
 523                         setting_password_ug_display_desc(ad, "No match with pattern", FALSE);
 524                         break;
 525                 case SETTING_PW_ERROR_NO_DIGIT:
 526                         setting_password_ug_display_desc(ad, "IDS_ST_BODY_PASSWORD_MUST_CONTAIN_AT_LEAST_1_NUMBER", FALSE);
 527                         break;
 528                 default:
 529                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 530                         break;
 531         }
 532 }
 533
 534 int setting_password_main_check_1line_password(void *data)
 535 {
 536         /* error check */
 537         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 538
 539         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 540
 541         /*const char *entry_str = ad->ed_pw1->sub_desc; */
 542         const char *entry_str = elm_entry_markup_to_utf8(ad->ed_pw1->sub_desc);
 543         /*char* plain_str = elm_entry_markup_to_utf8(ad->ed_pw1->sub_desc); */
 544         ad->focus_data = ad->ed_pw1;
 545
 546         /*  Empty Check */
 547         if (isEmptyStr(entry_str)) {
 548                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
 549                 FREE(entry_str);
 550                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
 551         }
 552
 553         /*  Length Check */
 554         int entry_str_len = safeStrLen(entry_str);
 555         if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
 556             || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
 557                 setting_password_main_warning_entry_added_byte_popup(ad,
 558                                                                      SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH,
 559                                                                      SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
 560                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
 561         }
 562         return SETTING_RETURN_SUCCESS;
 563 }
 564
 565 int setting_password_main_check_2line_password(void *data)
 566 {
 567         SETTING_TRACE_BEGIN;
 568         /* error check */
 569         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 570
 571         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 572         if (ad->ed_pw1 == NULL)
 573                 return SETTING_GENERAL_ERR_NULL_DATA_PARAMETER;
 574
 575         const char *entry_str1 = ad->step1_str;
 576         const char *entry_str2 = ad->ed_pw1->sub_desc;
 577
 578         /*SETTING_TRACE(" entry_str1 : %s ", entry_str1); */
 579         /*SETTING_TRACE(" entry_str2 : %s ", entry_str2); */
 580
 581         /*char* plain_str = elm_entry_markup_to_utf8(str); */
 582         const char *entry_str1_mk = elm_entry_markup_to_utf8(entry_str1);
 583         const char *entry_str2_mk = elm_entry_markup_to_utf8(entry_str2);
 584
 585         ad->focus_data = ad->ed_pw1;
 586
 587         /*  Empty Check */
 588         if (isEmptyStr(entry_str1_mk)) {
 589                 setting_password_ug_display_desc(ad, _("IDS_ST_BODY_PASSWORD_EMPTY"), FALSE);
 590                 FREE(entry_str1_mk);
 591                 FREE(entry_str2_mk);
 592                 return SETTING_ENTRY_RETURN_NULL_STR_ERR;
 593         }
 594
 595         /*  Match Check */
 596         if (0 != safeStrCmp(entry_str1_mk, entry_str2_mk)) {
 597                 setting_password_main_clear_1line_password(ad);
 598                 setting_password_ug_display_desc(ad, _("IDS_ST_POP_PASSWORDS_DO_NOT_MATCH"), FALSE);
 599                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
 600         }
 601
 602         /*  Length Check */
 603         int entry_str_len = safeStrLen(entry_str1_mk);
 604         if (entry_str_len < SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH
 605             || entry_str_len > SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH) {
 606                 setting_password_main_warning_entry_added_byte_popup(ad,
 607                                                                      SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH,
 608                                                                      SETTING_PW_UG_NORMAL_PASSWORD_MAX_LENGTH);
 609                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
 610         }
 611
 612         return SETTING_RETURN_SUCCESS;
 613 }
 614
 615 void setting_password_main_warning_entry_added_byte_popup(SettingPasswordUG *ad,
 616                                                           int min, int max)
 617 {
 618         char str[MAX_SPECIALIZITION_LEN + 1] = { 0 };
 619
 620         snprintf(str, MAX_SPECIALIZITION_LEN, _("IDS_ST_POP_PASSWORD_MUST_BE_MORE_THAN_P1SD_CHARACTERS_AND_LESS_THAN_P2SD"), min, max);
 621         setting_password_ug_display_desc(ad, str, FALSE);
 622 }
 623
 624 static void setting_password_main_done_password(void *data)
 625 {
 626         ret_if(data == NULL);
 627         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 628
 629         app_control_h svc;
 630         if (app_control_create(&svc)) {
 631                 SETTING_TRACE_ERROR("app_control_create() failed");
 632                 return;
 633         }
 634
 635         SETTING_TRACE("ad->view_type:%d", ad->view_type);
 636         int ret = 0;
 637
 638         switch (ad->view_type) {
 639                 case SETTING_PW_TYPE_PASSWORD:
 640                         ret = setting_password_main_check_1line_password(ad);
 641
 642                         if (ret == SETTING_RETURN_SUCCESS) {
 643                                 const char *entry_str;
 644                                 entry_str = ad->ed_pw1->sub_desc;
 645                                 /*SETTING_TRACE(" ----> entry_str : %s ", entry_str); */
 646                                 /*SETTING_TRACE(" ----> ad->view_type_string : %s ", ad->view_type_string); */
 647                                 unsigned int remain_attempt = ATTEMPT_INFINITE;
 648                                 unsigned int valid_seconds = 0;
 649
 650                                 ret = setting_password_check_password(entry_str, &remain_attempt, &valid_seconds);
 651
 652                                 if (ret == SETTING_RETURN_SUCCESS) {
 653                                         int err;
 654
 655                                         if (safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_PASSWORD") == 0) {
 656
 657                                                 /*  reset VCONF */
 658                                                 setting_set_int_slp_key(INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT, PHONE_LOCK_ATTEMPS_MAX, &err);
 659                                                 if (err == SETTING_RETURN_FAIL) {
 660                                                         SETTING_TRACE_ERROR("[Error] set value of vconf fail.");
 661                                                         app_control_destroy(svc);
 662                                                         return;
 663                                                 }
 664                                         } else if (0 == safeStrCmp(ad->view_type_string, "SETTING_PW_TYPE_ENTER_LOCK_TYPE")) {
 665                                                 app_control_add_extra_data(svc, "current", entry_str);
 666                                         }
 667                                 } else {
 668                                         /*  Incorrect Password. Display Popup.   */
 669                                         setting_password_main_clear_1line_password(ad);
 670                                         ad->focus_data = ad->ed_pw1;
 671                                         /*else */
 672                                         /*{ */
 673                                         /*      setting_password_ug_check_attemps_left(ad); */
 674                                         /*      return; */
 675                                         /*} */
 676                                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 677                                         app_control_destroy(svc);
 678                                         return;
 679                                 }
 680                         } else {
 681                                 setting_password_main_clear_1line_password(ad);
 682                                 app_control_destroy(svc);
 683                                 return;
 684                         }
 685                         break;
 686                 case SETTING_PW_TYPE_SET_PASSWORD: {
 687                                 /*SETTING_TRACE("case SETTING_PW_TYPE_SET_PASSWORD"); */
 688                                 ret = setting_password_main_check_2line_password(ad);
 689                                 /*SETTING_TRACE("setting_password_main_check_2line_password --> ret = %d ", ret); */
 690
 691                                 if (SETTING_RETURN_SUCCESS == ret) {
 692                                         const char *entry_str;
 693                                         entry_str = ad->ed_pw1->sub_desc;
 694
 695                                         if (isEmptyStr(entry_str)) {
 696                                                 ad->focus_data = ad->ed_pw1;
 697                                                 SETTING_TRACE_DEBUG("%s*** [ERR] elm_entry_entry_get return NULL ***%s",
 698                                                                     SETTING_FONT_RED, SETTING_FONT_BLACK);
 699                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_ERROR"), FALSE);
 700                                                 app_control_destroy(svc);
 701                                                 return;
 702                                         }
 703
 704                                         ret = setting_password_set_password(ad->cur_pwd, entry_str, ad);
 705                                         SETTING_TRACE(" -----------------> setting_password_set_password : %d \n", ret);
 706
 707                                         /*  Modify Setting Password */
 708                                         if (ret > 0) {
 709                                                 /*  Display popup */
 710                                                 /*service_add_extra_data(svc, "current", entry_str); */
 711                                                 if (ad->set_history_timer) {
 712                                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_NEW_PASSWD_SAVED"), FALSE);
 713                                                 } else {
 714                                                         app_control_add_extra_data(svc, "result", ad->view_type_string);
 715                                                         ug_send_result(ad->ug, svc);
 716                                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 717
 718                                                         app_control_destroy(svc);
 719                                                         /* Send destroy request */
 720                                                         ug_destroy_me(ad->ug);
 721                                                         return;
 722                                                 }
 723                                                 app_control_destroy(svc);
 724                                                 return;
 725                                         } else if (ret == SETTING_PW_ERROR_REUSED) {
 726                                                 ad->focus_data = ad->ed_pw1;
 727                                                 setting_password_main_clear_1line_password(ad);
 728                                                 setting_password_ug_display_desc(ad, _(PW_ERR_REUSED), FALSE);
 729                                                 app_control_destroy(svc);
 730                                                 return;
 731                                         } else {
 732                                                 ad->focus_data = ad->ed_pw1;
 733                                                 setting_password_main_clear_1line_password(ad);
 734                                                 setting_password_ug_display_desc(ad, _("IDS_BT_POP_OPERATION_FAILED"), FALSE);
 735                                                 app_control_destroy(svc);
 736                                                 return;
 737                                         }
 738                                 } else if (SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW == ret) {
 739                                         /* Nothing */
 740                                         app_control_destroy(svc);
 741                                         setting_password_main_clear_1line_password(ad);
 742                                         setting_password_ug_display_desc(ad, PW_ST_PW_DO_NOT_MATCH, FALSE);
 743                                         return;
 744                                 } else {
 745                                         SETTING_TRACE("error : %d", ret);
 746                                         setting_password_main_clear_1line_password(ad);
 747                                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 748                                         app_control_destroy(svc);
 749                                         return;
 750                                 }
 751                         }
 752                         break;
 753                 default:
 754                         app_control_destroy(svc);
 755                         return;
 756         }
 757
 758         app_control_add_extra_data(svc, "result", ad->view_type_string);
 759         ug_send_result(ad->ug, svc);
 760         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 761
 762         app_control_destroy(svc);
 763         /* Send destroy request */
 764         ug_destroy_me(ad->ug);
 765 }
 766
 767 static int __count_string(const char *str, int *cnt_letter, int *cnt_digit, int *cnt_sym)
 768 {
 769         SETTING_TRACE_BEGIN;
 770         retv_if(str == NULL || cnt_letter == NULL || cnt_digit == NULL || cnt_sym == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 771
 772         /*char* plain_str = elm_entry_markup_to_utf8(str); */
 773         char *plain_str = str;
 774
 775         int length = strlen(plain_str);
 776         int index = 0;
 777         char temp = 0;
 778         int letter = 0;
 779         int digit = 0;
 780         int symbol = 0;
 781
 782         if (length <= 0) {
 783                 SETTING_TRACE_DEBUG("[DEBUG] invalid input length");
 784                 return SETTING_RETURN_FAIL;
 785         }
 786
 787         for (index = 0; index < length; index++) {
 788                 temp = (char)(plain_str[index]);
 789                 SETTING_TRACE_SECURE_DEBUG("temp %c", temp);
 790
 791                 if ((temp >= '0') && (temp <= '9')) {   /* digit */
 792                         digit++;
 793                 } else if ((temp >= 'a') && (temp <= 'z')) {    /* lower letter */
 794                         letter++;
 795                 } else if ((temp >= 'A') && (temp <= 'Z')) {    /* upper letter */
 796                         letter++;
 797                 } else if ((temp >= ' ') && (temp <= '~')) { /* symbol means special char that enables to input from IME. */
 798                         symbol++;
 799                 }
 800         }
 801         SETTING_TRACE_SECURE_DEBUG("%s includes %d letters, %d digits, and %d symbols", plain_str, letter, digit, symbol);
 802         *cnt_letter = letter;
 803         *cnt_digit = digit;
 804         *cnt_sym = symbol;
 805         return SETTING_RETURN_SUCCESS;
 806 }
 807
 808 void setting_password_main_click_softkey_continue_cb(void *data, Evas_Object *obj,
 809                                                      void *event_info)
 810 {
 811         /* error check */
 812         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
 813
 814         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 815
 816         /* Save first input */
 817         ad->step1_str = (char *)strdup(ad->ed_pw1->sub_desc);
 818
 819
 820         /* Check step1_str : more than 4, not all digits */
 821         int letter = 0;
 822         int digit = 0;
 823         int symbol = 0;
 824         char *plain_str = elm_entry_markup_to_utf8(ad->step1_str);
 825         __count_string(plain_str, &letter, &digit, &symbol);
 826         if (safeStrLen(plain_str) != digit) {
 827                 __add_help_of_password_fails(SETTING_PW_ERROR_INCLUDE_NO_LETTER, ad);
 828                 FREE(ad->step1_str);
 829                 FREE(plain_str);
 830                 return;
 831         }
 832
 833         setting_password_main_clear_1line_password(ad);
 834         if (ad->err_desc && ad->err_desc->item) {
 835                 elm_object_item_del(ad->err_desc->item);
 836                 ad->err_desc = NULL;
 837         }
 838
 839         /* Change entry title : PW_SHORT_GUIDE_CONFIRM */
 840         FREE(ad->ed_pw1->keyStr);
 841         ad->ed_pw1->keyStr = (char *)strdup(PW_SHORT_GUIDE_CONFIRM);
 842         elm_genlist_item_fields_update(ad->ed_pw1->item, "elm.text.main", ELM_GENLIST_ITEM_FIELD_TEXT);
 843
 844
 845         /* Change button */
 846         if (ad->bottom_btn) {
 847                 elm_object_text_set(ad->bottom_btn, _("IDS_SA_BUTTON_DONE_ABB"));
 848                 evas_object_smart_callback_add(ad->bottom_btn, "clicked", setting_password_main_click_softkey_done_cb, ad);
 849                 elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 850         }
 851
 852         ad->cur_step++;
 853         FREE(plain_str);
 854 }
 855
 856 void setting_password_main_click_softkey_done_cb(void *data, Evas_Object *obj,
 857                                                  void *event_info)
 858 {
 859         /* error check */
 860         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
 861
 862         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 863
 864         if (ad->ed_pw1 && ad->ed_pw1->eo_check) {
 865                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_FALSE);
 866         }
 867
 868         if (ad->err_desc && ad->err_desc->item) {
 869                 elm_object_item_del(ad->err_desc->item);
 870                 ad->err_desc = NULL;
 871         }
 872
 873         setting_password_main_done_password(ad);
 874 }