setting-password/src/setting-password.c

   1 /*
   2   * Copyright 2012  Samsung Electronics Co., Ltd
   3   *
   4   * Licensed under the Flora License, Version 1.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7   *
   8   *     http://www.tizenopensource.org/license
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16
  17
  18 #include <setting-password.h>
  19 #ifndef UG_MODULE_API
  20 #define UG_MODULE_API __attribute__ ((visibility("default")))
  21 #endif
  22
  23 static tapi_request_event tapi_req_events[] = {
  24         {-1, TAPI_EVENT_SIM_CHANGE_PINS_CNF},
  25         {-1, TAPI_EVENT_SIM_DISABLE_SEC_CNF},
  26         {-1, TAPI_EVENT_SIM_ENABLE_SEC_CNF},
  27         {-1, TAPI_EVENT_SIM_VERIFY_SEC_CNF},
  28         {-1, TAPI_EVENT_SIM_VERIFY_PUK_CNF},
  29         {-1, TAPI_EVENT_SIM_DISABLE_FDNMODE_CNF},
  30         {-1, TAPI_EVENT_SIM_ENABLE_FDNMODE_CNF},
  31         {-1, TAPI_EVENT_SIM_ENABLE_PERS_CNF},
  32         {-1, TAPI_EVENT_SIM_DISABLE_PERS_CNF},
  33         {-1, TAPI_EVENT_SIM_PERS_STATUS_CNF},
  34 };
  35
  36 static struct _pw_item pw_its[] = {
  37         { SETTING_PW_TYPE_POWER_ON_LOCK, "SETTING_PW_TYPE_POWER_ON_LOCK" },
  38         { SETTING_PW_TYPE_PHONE_LOCK, "SETTING_PW_TYPE_PHONE_LOCK" },
  39         { SETTING_PW_TYPE_PHONE_LOCK_ON, "SETTING_PW_TYPE_PHONE_LOCK_ON" },
  40         { SETTING_PW_TYPE_SET_PASSWORD, "SETTING_PW_TYPE_SET_PASSWORD" },
  41         { SETTING_PW_TYPE_SIMPLE_PASSWORD, "SETTING_PW_TYPE_SIMPLE_PASSWORD" },
  42         { SETTING_PW_TYPE_CHANGE_PASSWORD, "SETTING_PW_TYPE_CHANGE_PASSWORD" },
  43         { SETTING_PW_TYPE_SIM_LOCK_ON, "SETTING_PW_TYPE_SIM_LOCK_ON" },
  44         { SETTING_PW_TYPE_SIM_LOCK_OFF, "SETTING_PW_TYPE_SIM_LOCK_OFF" },
  45         { SETTING_PW_TYPE_PIN_LOCK_ON, "SETTING_PW_TYPE_PIN_LOCK_ON" },
  46         { SETTING_PW_TYPE_PIN_LOCK_OFF, "SETTING_PW_TYPE_PIN_LOCK_OFF" },
  47         { SETTING_PW_TYPE_CHANGE_PIN1, "SETTING_PW_TYPE_CHANGE_PIN1" },
  48         { SETTING_PW_TYPE_FDN_MODE_ON, "SETTING_PW_TYPE_FDN_MODE_ON" },
  49         { SETTING_PW_TYPE_FDN_MODE_OFF, "SETTING_PW_TYPE_FDN_MODE_OFF" },
  50         { SETTING_PW_TYPE_CHANGE_PIN2, "SETTING_PW_TYPE_CHANGE_PIN2" },
  51         { SETTING_PW_TYPE_PIN1_BLOCKED, "SETTING_PW_TYPE_PIN1_BLOCKED" },
  52         { SETTING_PW_TYPE_PIN2_BLOCKED, "SETTING_PW_TYPE_PIN2_BLOCKED" },
  53         { SETTING_PW_TYPE_RESET, "SETTING_PW_TYPE_RESET" },
  54         { SETTING_PW_TYPE_CLEAR, "SETTING_PW_TYPE_CLEAR"},
  55         { SETTING_PW_TYPE_LOCK_FOR_APP, "SETTING_PW_TYPE_LOCK_FOR_APP"}, /* used by other app */
  56         { SETTING_PW_TYPE_MAX, NULL }
  57 };
  58
  59 static void setting_tapi_init(SettingPasswordUG *ad);
  60 static void setting_password_ug_display_result_popup(tapi_receive_info *result, SettingPasswordUG *ad);
  61 static int setting_password_ug_sim_event_callback(const TelTapiEvent_t *event, void *data);
  62
  63 static void setting_password_ug_cb_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
  64 {
  65         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  66         setting_view_update(&setting_view_password_main, ad);
  67 }
  68
  69 static void setting_tapi_init(SettingPasswordUG *ad)
  70 {
  71         SETTING_TRACE_BEGIN;
  72         switch (ad->view_type) {
  73         case SETTING_PW_TYPE_SIM_LOCK_ON:
  74         case SETTING_PW_TYPE_SIM_LOCK_OFF:
  75         case SETTING_PW_TYPE_PIN_LOCK_ON:
  76         case SETTING_PW_TYPE_PIN_LOCK_OFF:
  77         case SETTING_PW_TYPE_CHANGE_PIN1:
  78         case SETTING_PW_TYPE_CHANGE_PIN2:
  79         case SETTING_PW_TYPE_FDN_MODE_ON:
  80         case SETTING_PW_TYPE_FDN_MODE_OFF:
  81         case SETTING_PW_TYPE_PIN1_BLOCKED:
  82         case SETTING_PW_TYPE_PIN2_BLOCKED:
  83                 /* subscribe tapi events */
  84                 if (setting_password_ug_subscribe_sim_events(ad) != SETTING_RETURN_SUCCESS) {
  85                         SETTING_TRACE_DEBUG
  86                             ("%s*** [ERR] setting_security_subscribe_sim_events. ***%s",
  87                              SETTING_FONT_RED, SETTING_FONT_BLACK);
  88                         setting_password_ug_create_popup_notitle_nobtn(ad,
  89                                                                        _("IDS_COM_POP_ERROR"),
  90                                                                        FALSE);
  91                 }
  92                 break;
  93         default:
  94                 break;
  95         }
  96         SETTING_TRACE_END;
  97 }
  98
  99 static void setting_tapi_finize(SettingPasswordUG *ad)
 100 {
 101         SETTING_TRACE_BEGIN;
 102         switch (ad->view_type) {
 103         case SETTING_PW_TYPE_SIM_LOCK_ON:
 104         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 105         case SETTING_PW_TYPE_PIN_LOCK_ON:
 106         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 107         case SETTING_PW_TYPE_CHANGE_PIN1:
 108         case SETTING_PW_TYPE_CHANGE_PIN2:
 109         case SETTING_PW_TYPE_FDN_MODE_ON:
 110         case SETTING_PW_TYPE_FDN_MODE_OFF:
 111         case SETTING_PW_TYPE_PIN1_BLOCKED:
 112         case SETTING_PW_TYPE_PIN2_BLOCKED:
 113                 /* unsubscribe tapi events */
 114                 if (setting_password_ug_unsubscribe_sim_events(ad) != SETTING_RETURN_SUCCESS) {
 115                         SETTING_TRACE_DEBUG
 116                             ("%s*** [ERR] setting_security_subscribe_sim_events. ***%s",
 117                              SETTING_FONT_RED, SETTING_FONT_BLACK);
 118                         setting_password_ug_create_popup_notitle_nobtn(ad,
 119                                                                        _("IDS_COM_POP_ERROR"),
 120                                                                        FALSE);
 121                 }
 122                 break;
 123         default:
 124                 break;
 125         }
 126         SETTING_TRACE_END;
 127 }
 128
 129 setting_pw_type __get_password_view_type(SettingPasswordUG *ad, bundle *data)
 130 {
 131         SETTING_TRACE_BEGIN;
 132         setting_retvm_if(NULL == data, -1, "NULL == data");
 133         ad->view_type_string = bundle_get_val(data, "viewtype");
 134         SETTING_TRACE("viewtype:%s", ad->view_type_string);
 135         setting_pw_type ret_pw_type = 0;
 136         int i;
 137
 138         for(i = 0; i < SETTING_PW_TYPE_MAX; i++)
 139         {
 140                 if (0 == safeStrCmp(ad->view_type_string, pw_its[i].pw_type_string))
 141                 {
 142                         ret_pw_type = pw_its[i].pw_type_num;
 143                         break;
 144                 }
 145         }
 146
 147         if( (ret_pw_type == SETTING_PW_TYPE_PHONE_LOCK) ||
 148                 (ret_pw_type == SETTING_PW_TYPE_SIMPLE_PASSWORD) ||
 149                 (ret_pw_type == SETTING_PW_TYPE_LOCK_FOR_APP) ||
 150                 (ret_pw_type == SETTING_PW_TYPE_CHANGE_PASSWORD) ||
 151                 (ret_pw_type == SETTING_PW_TYPE_RESET) )
 152         {
 153                 if(setting_password_is_password_empty() == TRUE)
 154                 {
 155                         ret_pw_type = SETTING_PW_TYPE_SET_PASSWORD;
 156                 }
 157         }
 158
 159         return ret_pw_type;
 160 }
 161
 162 static void setting_password_ug_set_password_cb(void *data, Evas_Object *obj,
 163                                                 void *event_info)
 164 {
 165         /* error check */
 166         retm_if(data == NULL, "Data parameter is NULL");
 167
 168         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 169
 170         switch (btn_type(obj)) {
 171         case POPUP_RESPONSE_OK:
 172                 {
 173                         /*  creating a view. */
 174                         setting_view_create(&setting_view_password_main, (void *)ad);
 175                         evas_object_event_callback_add(ad->win_main_layout,
 176                                                        EVAS_CALLBACK_RESIZE,
 177                                                        setting_password_ug_cb_resize,
 178                                                        ad);
 179                         if(ad->setpw_notify)
 180                         {
 181                                 evas_object_del(ad->setpw_notify);
 182                                 ad->setpw_notify = NULL;
 183                         }
 184                 }
 185                 break;
 186
 187         case POPUP_RESPONSE_CANCEL:
 188                 {
 189                         if (ad->setpw_notify)
 190                         {
 191                                 evas_object_del(ad->setpw_notify);
 192                                 ad->setpw_notify = NULL;
 193                         }
 194
 195                         ug_destroy_me(ad->ug);
 196                 }
 197                 break;
 198         default:
 199                 break;
 200         }
 201 }
 202
 203 static char *__gl_err_desc_text_get(void *data, Evas_Object *obj, const char *part)
 204 {
 205         retv_if(data == NULL, NULL);
 206         char buf[256] = {0,};
 207
 208         snprintf(buf, sizeof(buf)-1, "<font color=#ff0000>%s</font>", (char*)data);
 209
 210         return strdup(buf);
 211 }
 212
 213 static void *setting_password_ug_on_create(struct ui_gadget *ug,
 214                                            enum ug_mode mode, bundle *data,
 215                                            void *priv)
 216 {
 217         setting_retvm_if((!ug || !priv), NULL, "!ug || !priv");
 218
 219         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 220         passwordUG->ug = ug;
 221         passwordUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 222         passwordUG->win_get = (Evas_Object *) ug_get_window();
 223         evas_object_show(passwordUG->win_main_layout);
 224         passwordUG->evas = evas_object_evas_get(passwordUG->win_main_layout);
 225
 226         setting_retvm_if(passwordUG->win_main_layout == NULL, NULL,
 227                          "cannot get main window ");
 228
 229         /* --------------------------------------------------------- */
 230         char *pa_path = NULL;;
 231
 232         pa_path = vconf_get_str(VCONFKEY_LANGSET);
 233         if (!pa_path) {
 234                 SETTING_TRACE
 235                     ("%s*** language setting has no proper value (nil) ***%s",
 236                      SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 237                 return NULL;
 238         }
 239         /* set launguage */
 240         setlocale(LC_ALL, "");
 241         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
 242         FREE(pa_path);
 243         /* --------------------------------------------------------- */
 244
 245         setting_create_Gendial_itc("dialogue/title", &(passwordUG->itc_title));
 246         setting_create_Gendial_itc("dialogue/1icon",&(passwordUG->itc_variable_height));
 247         passwordUG->itc_seperator.item_style = "dialogue/separator/21/with_line";
 248         passwordUG->itc_seperator.func.text_get = NULL;
 249         passwordUG->itc_seperator.func.content_get = NULL;
 250         passwordUG->itc_seperator.func.state_get = NULL;
 251         passwordUG->itc_seperator.func.del = NULL;
 252
 253         passwordUG->itc_err_desc.item_style = "multiline/1text";
 254         passwordUG->itc_err_desc.func.text_get = __gl_err_desc_text_get;
 255         passwordUG->itc_err_desc.func.content_get = NULL;
 256         passwordUG->itc_err_desc.func.state_get = NULL;
 257         passwordUG->itc_err_desc.func.del = NULL;
 258
 259         /* init */
 260         ecore_imf_init();
 261         passwordUG->view_type = __get_password_view_type(passwordUG, data);
 262         setting_tapi_init(passwordUG);
 263
 264         /* get simple password flag */
 265         if(vconf_get_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, &(passwordUG->is_simple_password_on)) < 0)
 266                 passwordUG->is_simple_password_on = 0;
 267
 268         SETTING_TRACE_DEBUG("simple password is %d", passwordUG->is_simple_password_on);
 269
 270                 if (SETTING_PW_TYPE_SET_PASSWORD == passwordUG->view_type)
 271                 {
 272                 if( strcmp(passwordUG->view_type_string, "SETTING_PW_TYPE_RESET") == 0)
 273                 {       /* no need to set password, in this case.*/
 274                         bundle *b = bundle_create();
 275                         if (!b)
 276                                 return NULL;
 277
 278                         bundle_add(b, "result", passwordUG->view_type_string);
 279                         ug_send_result(passwordUG->ug, b);
 280                         SETTING_TRACE("Send Result : %s\n", passwordUG->view_type_string);
 281                         bundle_free(b);
 282                         /* Send destroy request */
 283                         ug_destroy_me(passwordUG->ug);
 284                 }
 285                 /*  Make a popup */
 286                         passwordUG->setpw_notify = setting_create_popup_with_btn(passwordUG,
 287                                          (Evas_Object *) ug_get_window(),
 288                                          _("IDS_ST_POP_NO_PASSWORD_SET_PASSWORD_Q"),
 289                                          NULL,
 290                                          setting_password_ug_set_password_cb,
 291                                          0, 2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
 292
 293                 /*  Make a Layout */
 294                 passwordUG->ly_main = elm_layout_add(passwordUG->win_main_layout);
 295                 if (passwordUG->ly_main == NULL)
 296                         return NULL;
 297                 evas_object_hide(passwordUG->ly_main);
 298
 299                 return passwordUG->ly_main;
 300         } else {
 301                 /*  creating a view. */
 302                 setting_view_create(&setting_view_password_main,(void *)passwordUG);
 303                 evas_object_event_callback_add(passwordUG->win_main_layout,
 304                                                EVAS_CALLBACK_RESIZE,
 305                                                setting_password_ug_cb_resize,
 306                                                passwordUG);
 307                 return passwordUG->ly_main;
 308         }
 309 }
 310
 311 static void setting_password_ug_on_start(struct ui_gadget *ug, bundle *data, void *priv)
 312 {
 313         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 314
 315         /* handle focus of entry */
 316         if(passwordUG->sp_entry1 != NULL)
 317         {
 318                 SETTING_TRACE_DEBUG("sp_entry1 is exist.");
 319                 elm_object_focus_set(passwordUG->sp_entry1, EINA_TRUE);
 320                 passwordUG->sp_focused = passwordUG->sp_entry1;
 321         }
 322 }
 323
 324 static void setting_password_ug_on_pause(struct ui_gadget *ug, bundle *data, void *priv)
 325 {
 326 }
 327
 328 static void setting_password_ug_on_resume(struct ui_gadget *ug, bundle *data, void *priv)
 329 {
 330 }
 331
 332 static void setting_password_ug_on_destroy(struct ui_gadget *ug, bundle *data, void *priv)
 333 {
 334         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 335
 336         evas_object_event_callback_del(passwordUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_password_ug_cb_resize);       /* fix flash issue for gallery */
 337         passwordUG->ug = ug;
 338         setting_tapi_finize(passwordUG);
 339
 340         if (passwordUG->t_info) {
 341                 FREE(passwordUG->t_info);
 342         }
 343
 344         if(passwordUG->remove_timer)
 345         {
 346                 ecore_timer_del(passwordUG->remove_timer);
 347                 passwordUG->remove_timer = NULL;
 348         }
 349
 350         /* release */
 351         ecore_imf_shutdown();
 352
 353         /*  delete the allocated objects. */
 354         setting_view_destroy(&setting_view_password_main, passwordUG);
 355         if (NULL != ug_get_layout(passwordUG->ug)) {
 356                 evas_object_hide((Evas_Object *) ug_get_layout(passwordUG->ug));
 357                 evas_object_del((Evas_Object *) ug_get_layout(passwordUG->ug));
 358         }
 359 }
 360
 361 static void setting_password_ug_on_message(struct ui_gadget *ug, bundle *msg,
 362                                            bundle *data, void *priv)
 363 {
 364
 365 }
 366
 367 static void setting_password_ug_on_event(struct ui_gadget *ug,
 368                                          enum ug_event event, bundle *data,
 369                                          void *priv)
 370 {
 371         switch (event) {
 372         case UG_EVENT_LOW_MEMORY:
 373                 break;
 374         case UG_EVENT_LOW_BATTERY:
 375                 break;
 376         case UG_EVENT_LANG_CHANGE:
 377                 break;
 378         case UG_EVENT_ROTATE_PORTRAIT:
 379                 break;
 380         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 381                 break;
 382         case UG_EVENT_ROTATE_LANDSCAPE:
 383                 break;
 384         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 385                 break;
 386         case UG_EVENT_REGION_CHANGE:
 387                 break;
 388         default:
 389                 break;
 390         }
 391 }
 392
 393 static void setting_password_ug_on_key_event(struct ui_gadget *ug,
 394                                              enum ug_key_event event,
 395                                              bundle *data, void *priv)
 396 {
 397         if (!ug || !priv)
 398                 return;
 399
 400         SettingPasswordUG *ad = (SettingPasswordUG*)priv;
 401
 402         switch (event) {
 403         case UG_KEY_EVENT_END:
 404                 if(ad->remove_timer)
 405                 {
 406                         ecore_timer_del(ad->remove_timer);
 407                         ad->remove_timer = NULL;
 408                 }
 409                 ug_destroy_me(ug);
 410                 break;
 411         default:
 412                 break;
 413         }
 414 }
 415
 416 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 417 {
 418         SettingPasswordUG *passwordUG = calloc(1, sizeof(SettingPasswordUG));
 419         setting_retvm_if(!passwordUG, -1, "Create SettingPasswordUG obj failed");
 420
 421         ops->create = setting_password_ug_on_create;
 422         ops->start = setting_password_ug_on_start;
 423         ops->pause = setting_password_ug_on_pause;
 424         ops->resume = setting_password_ug_on_resume;
 425         ops->destroy = setting_password_ug_on_destroy;
 426         ops->message = setting_password_ug_on_message;
 427         ops->event = setting_password_ug_on_event;
 428         ops->key_event = setting_password_ug_on_key_event;
 429         ops->priv = passwordUG;
 430         ops->opt = UG_OPT_INDICATOR_ENABLE;
 431
 432         return 0;
 433 }
 434
 435 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 436 {
 437         struct SettingPasswordUG *passwordUG;
 438         setting_retm_if(!ops, "ops == NULL");
 439
 440         passwordUG = ops->priv;
 441         if (passwordUG)
 442                 FREE(passwordUG);
 443 }
 444
 445 int setting_password_ug_subscribe_sim_events(SettingPasswordUG *ad)
 446 {
 447         int i = 0;
 448         int ret = SETTING_RETURN_SUCCESS;
 449         int tapi_ret = TAPI_API_SUCCESS;
 450         tapi_request_tapi_info *t_info;
 451
 452         if (tel_init() != TAPI_API_SUCCESS) {
 453                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_init. ***%s",
 454                                     SETTING_FONT_RED, SETTING_FONT_BLACK);
 455                 return SETTING_TAPI_INIT_ECORE_ERR;
 456         }
 457
 458         SETTING_TRACE_DEBUG("Tapi Init : %d", tapi_ret);
 459
 460         t_info = calloc(1, sizeof(tapi_request_tapi_info));
 461
 462         if (NULL == t_info) {
 463                 SETTING_TRACE_DEBUG("Tapi calloc data error\n");
 464                 return SETTING_RETURN_FAIL;
 465         }
 466
 467         t_info->evt = tapi_req_events;
 468         t_info->evt_sz = sizeof(tapi_req_events) / sizeof(tapi_req_events[0]);
 469         t_info->cb = NULL;
 470         t_info->cb_data = NULL;
 471
 472         SETTING_TRACE_DEBUG("Tapi Info Size : %d", t_info->evt_sz);
 473         for (i = 0; i < t_info->evt_sz; i++) {
 474                 tapi_ret =
 475                     tel_register_event(t_info->evt[i].event,
 476                                        &(t_info->evt[i].sid),
 477                                        (TelAppCallback) &
 478                                        setting_password_ug_sim_event_callback,
 479                                        ad);
 480                 SETTING_TRACE_DEBUG
 481                     ("TAPI Register Return : %d Event : %d sid: %d", tapi_ret,
 482                      t_info->evt[i].event, t_info->evt[i].sid);
 483         }
 484
 485         if (TAPI_API_SUCCESS == tapi_ret) {
 486                 tapi_ret = tel_register_app_name("org.tizen.setting");
 487
 488                 if (tapi_ret != TAPI_API_SUCCESS) {
 489                         SETTING_TRACE_DEBUG
 490                             ("%s*** [ERR] tel_register_app_name. ***%s",
 491                              SETTING_FONT_RED, SETTING_FONT_BLACK);
 492                         FREE(t_info);   /* memory leak */
 493                         return SETTING_TAPI_REG_EVENT_ECORE_ERR;
 494                 }
 495         }
 496         ad->t_info = t_info;
 497         return ret;
 498 }
 499
 500 int setting_password_ug_unsubscribe_sim_events(SettingPasswordUG *ad)
 501 {
 502         retv_if(ad == NULL, SETTING_GENERAL_ERR_WRONG_PARAMETER);
 503
 504         int i = 0;
 505         int ret = SETTING_RETURN_SUCCESS;
 506         int tapi_ret = TAPI_API_SUCCESS;
 507
 508         if (ad->t_info) {
 509                 tapi_request_tapi_info *t_info = ad->t_info;
 510                 SETTING_TRACE("T_INFO size : %d\n", t_info->evt_sz);
 511                 for (i = 0; i < t_info->evt_sz; i++) {
 512                         if (t_info->evt[i].sid == -1)
 513                                 continue;
 514
 515                         /* tapi_ret = tel_deregister_event_at_ecore_loop(t_info->evt[i].sid); */
 516                         tapi_ret = tel_deregister_event(t_info->evt[i].sid);
 517                         if (tapi_ret != TAPI_API_SUCCESS) {
 518                                 SETTING_TRACE_DEBUG
 519                                     ("%s*** [ERR] tel_deregister_event. %dth , sid =%d, tapi_ret=%d ***%s\n",
 520                                      SETTING_FONT_RED, i, t_info->evt[i].sid,
 521                                      tapi_ret, SETTING_FONT_BLACK);
 522                                 return SETTING_TAPI_DEREG_EVENT_ECORE_ERR;
 523                                 break;
 524                         } else {
 525                                 SETTING_TRACE
 526                                     ("Event unregistering succeeded [%dth : %d] [subscription ID: %d]",
 527                                      i, t_info->evt[i].event,
 528                                      t_info->evt[i].sid);
 529                         }
 530                 }
 531                 FREE(ad->t_info);
 532         }
 533
 534         tapi_ret = tel_deinit();
 535         if (tapi_ret != TAPI_API_SUCCESS) {
 536                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_deinit. tapi_ret=%d ***%s",
 537                                     SETTING_FONT_RED, tapi_ret,
 538                                     SETTING_FONT_BLACK);
 539                 return SETTING_TAPI_DEREG_EVENT_ECORE_ERR;
 540         }
 541         return ret;
 542 }
 543
 544 #ifdef Status
 545 #undef Status
 546 #endif
 547
 548 static int
 549 setting_password_ug_sim_event_callback(const TelTapiEvent_t *event, void *data)
 550 {
 551         retv_if(data == NULL || event == NULL, SETTING_GENERAL_ERR_WRONG_PARAMETER);
 552         SETTING_TRACE("event->EventClass=\t%d", (int)(event->EventClass));
 553         SETTING_TRACE("event->EventType=\t%d", event->EventType);
 554         SETTING_TRACE("event->Status=\t%d", event->Status);
 555         SETTING_TRACE("event->RequestId=\t%d", event->RequestId);
 556         SettingPasswordUG *ad = data;
 557
 558         tapi_receive_info result_info = { 0, };
 559         TelSimSecResult_t *sim_event_data = NULL;
 560         sim_event_data = (TelSimSecResult_t *) event->pData;
 561
 562         if (TAPI_EVENT_CLASS_SIM != event->EventClass || NULL == sim_event_data) {
 563                 SETTING_TRACE_DEBUG
 564                     ("EventClass is not EVENT_CLASS_SIM or sim_event_data is NULL!\n");
 565                 SETTING_TRACE_DEBUG("sim_event_data %p\n", sim_event_data);
 566                 return SETTING_RETURN_FAIL;
 567         }
 568
 569         switch (event->EventType) {
 570                 /*  Lock ON */
 571         case TAPI_EVENT_SIM_ENABLE_SEC_CNF:
 572                 {
 573                         SETTING_TRACE
 574                             ("CASE: TAPI_EVENT_SIM_ENABLE_SEC_CNF [Event Data Type: %d]",
 575                              sim_event_data->type);
 576
 577                         /*  Sim Lock  */
 578                         if (TAPI_SIM_PTYPE_SIM == sim_event_data->type) {
 579                                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status)
 580                                         result_info.stat = SIM_LOCK_ON_SUCCESS;
 581                                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == event->Status)
 582                                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 583                                 else {
 584                                         SETTING_TRACE_DEBUG("%s*** [ERR] INCORRECTED ***%s",
 585                                              SETTING_FONT_RED,
 586                                              SETTING_FONT_BLACK);
 587                                         return SETTING_RETURN_FAIL;
 588                                 }
 589                         }
 590                         /*  Pin Lock */
 591                         else if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 592                                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status)
 593                                         result_info.stat = SIM_PIN_LOCK_ON_SUCCESS;
 594                                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == event->Status) {
 595                                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 596                                         result_info.retry_cnt = sim_event_data->retry_count;
 597                                 } else if (TAPI_SIM_PUK_REQUIRED == event->Status)
 598                                         result_info.stat = SIM_PIN1_BLOCKED;
 599
 600                                 /*  Pre CCF */
 601                                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == event->Status
 602                                          || TAPI_SIM_CARD_ERROR == event->Status) {
 603                                         /*  popup */
 604                                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 605                                 }
 606                                 else {
 607                                         SETTING_TRACE_DEBUG
 608                                             ("%s*** [ERR] INCORRECTED ***%s",
 609                                              SETTING_FONT_RED,
 610                                              SETTING_FONT_BLACK);
 611                                         return SETTING_RETURN_FAIL;
 612                                 }
 613                         }
 614                 }
 615                 break;
 616
 617                 /*  Lock OFF                    */
 618         case TAPI_EVENT_SIM_DISABLE_SEC_CNF:
 619                 {
 620                         SETTING_TRACE
 621                             ("CASE: TAPI_EVENT_SIM_DISABLE_SEC_CNF [Event Data Type: %d]",
 622                              sim_event_data->type);
 623
 624                         /*  Sim Lock  */
 625                         if (TAPI_SIM_PTYPE_SIM == sim_event_data->type) {
 626                                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status)
 627                                         result_info.stat = SIM_LOCK_OFF_SUCCESS;
 628                                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == event->Status)
 629                                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 630                                 else {
 631                                         SETTING_TRACE_DEBUG
 632                                             ("%s*** [ERR] INCORRECTED ***%s",
 633                                              SETTING_FONT_RED,
 634                                              SETTING_FONT_BLACK);
 635                                         return SETTING_RETURN_FAIL;
 636                                 }
 637                         }
 638                         /*  Pin Lock */
 639                         else if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 640                                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status)
 641                                         result_info.stat = SIM_PIN_LOCK_OFF_SUCCESS;
 642                                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == event->Status) {
 643                                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 644                                         result_info.retry_cnt = sim_event_data->retry_count;
 645                                 } else if (TAPI_SIM_PUK_REQUIRED == event->Status)
 646                                         result_info.stat = SIM_PIN1_BLOCKED;
 647
 648                                 /*  Pre CCF */
 649                                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == event->Status
 650                                          || TAPI_SIM_CARD_ERROR == event->Status) {
 651                                         /*  popup */
 652                                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 653                                 }
 654                                 else {
 655                                         SETTING_TRACE_DEBUG
 656                                             ("%s*** [ERR] INCORRECTED ***%s",
 657                                              SETTING_FONT_RED,
 658                                              SETTING_FONT_BLACK);
 659                                         return SETTING_RETURN_FAIL;
 660                                 }
 661                         }
 662                 }
 663                 break;
 664
 665                 /*  Verify PUK1, PUK2 */
 666         case TAPI_EVENT_SIM_VERIFY_PUK_CNF:
 667                 {
 668                         SETTING_TRACE
 669                             ("CASE: TAPI_EVENT_SIM_VERIFY_PUK_CNF [Event Data Type: %d]",
 670                              sim_event_data->type);
 671
 672                         TelSimPinStatus_t pin_status = -1;
 673                         TelSimPinType_t pin_type = 0;
 674
 675                         if (TAPI_SIM_PTYPE_PUK1 == sim_event_data->type)
 676                                 pin_type = TAPI_SIM_PTYPE_PIN1;
 677                         else if (TAPI_SIM_PTYPE_PUK2 == sim_event_data->type)
 678                                 pin_type = TAPI_SIM_PTYPE_PIN2;
 679                         else {
 680                                 SETTING_TRACE_DEBUG
 681                                     ("%s*** [ERR] Invalid pin_type ***%s",
 682                                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 683                                 return SETTING_RETURN_FAIL;
 684                         }
 685
 686                         int tapi_ret = tel_get_sim_security_status(pin_type, &pin_status);
 687                         SETTING_TRACE
 688                             ("TAPI RET : %d PIN_TYPE : %d PIN_STATUS : %d\n",
 689                              tapi_ret, pin_type, pin_status);
 690                         if (TAPI_API_SUCCESS != tapi_ret) {
 691                                 SETTING_TRACE_DEBUG
 692                                     ("%s*** [ERR] tel_get_sim_security_status ***%s",
 693                                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 694                                 return SETTING_RETURN_FAIL;
 695                         }
 696                         /*  Puk Blocked */
 697                         if (TAPI_SIM_PIN_STATUS_PUK_BLOCKED == pin_status) {
 698                                 if (TAPI_SIM_PTYPE_PIN1 == pin_type)
 699                                         result_info.stat = SIM_PUK1_BLOCKED;
 700                                 else
 701                                         result_info.stat = SIM_PUK2_BLOCKED;
 702                         }
 703                         /*  Pin Blocked and verifying puk code */
 704                         else if (TAPI_SIM_PIN_STATUS_ENABLED == pin_status) {
 705                                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status) {
 706                                         if (TAPI_SIM_PTYPE_PIN1 == pin_type)
 707                                                 result_info.stat = SIM_PIN1_UNBLOCKED;
 708                                         else
 709                                                 result_info.stat = SIM_PIN2_UNBLOCKED;
 710                                 }
 711                         }
 712                         /*  Pin Block */
 713                         else if (TAPI_SIM_PIN_STATUS_BLOCKED == pin_status) {
 714                                 if (TAPI_SIM_PTYPE_PIN1 == pin_type) {
 715                                         result_info.stat = SIM_INCORRECT_PUK1_CODE;
 716                                         result_info.retry_cnt = sim_event_data->retry_count;
 717                                 } else {
 718                                         result_info.stat = SIM_INCORRECT_PUK2_CODE;
 719                                         result_info.retry_cnt = sim_event_data->retry_count;
 720                                 }
 721                         } else {
 722                                 SETTING_TRACE_DEBUG
 723                                     ("%s*** [ERR] INCORRECTED ***%s",
 724                                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 725                                 result_info.stat = SIM_UNKNOWN_ERROR;
 726                         }
 727                 }
 728                 break;
 729
 730                 /*  Change PIN1, PIN2 */
 731         case TAPI_EVENT_SIM_CHANGE_PINS_CNF:
 732                 {
 733                         SETTING_TRACE
 734                             ("CASE: TAPI_EVENT_SIM_CHANGE_PINS_CNF [Event Data Type: %d]",
 735                              sim_event_data->type);
 736
 737                         if (TAPI_SIM_PIN_OPERATION_SUCCESS == event->Status) {
 738                                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 739                                         result_info.stat = SIM_PIN1_CHANGE_SUCCESS;
 740                                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 741                                         result_info.stat = SIM_PIN2_CHANGE_SUCCESS;
 742                         } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == event->Status) {
 743                                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 744                                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 745                                         result_info.retry_cnt = sim_event_data->retry_count;
 746                                 } else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type) {
 747                                         result_info.stat = SIM_INCORRECT_PIN2_CODE;
 748                                         result_info.retry_cnt = sim_event_data->retry_count;
 749                                 }
 750                         } else if (TAPI_SIM_PUK_REQUIRED == event->Status) {
 751                                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 752                                         result_info.stat = SIM_PIN1_BLOCKED;
 753                                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 754                                         result_info.stat = SIM_PIN2_BLOCKED;
 755                         } else {
 756                                 SETTING_TRACE_DEBUG
 757                                     ("%s*** [ERR] INCORRECTED ***%s",
 758                                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 759                                 return SETTING_RETURN_FAIL;
 760                         }
 761                 }
 762                 break;
 763
 764         default:
 765                 break;
 766         }
 767
 768         setting_password_ug_display_result_popup(&result_info, ad);
 769
 770         return 0;
 771 }
 772
 773 static void setting_password_ug_display_result_popup(tapi_receive_info *result,
 774                                                      SettingPasswordUG *ad)
 775 {
 776         switch (result->stat) {
 777         case SIM_OPERATION_OK:
 778         case SIM_LOCK_ON_SUCCESS:
 779         case SIM_LOCK_OFF_SUCCESS:
 780         case SIM_PIN_LOCK_ON_SUCCESS:
 781         case SIM_PIN_LOCK_OFF_SUCCESS:
 782                 {
 783                         if (ad->view_type ==
 784                             SETTING_PW_TYPE_SIM_LOCK_OFF) {
 785                                 int err = SETTING_RETURN_SUCCESS;
 786                                 /*  reset VCONF */
 787                                 setting_set_int_slp_key
 788                                     (INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,
 789                                      SIM_LOCK_ATTEMPS_MAX, &err);
 790                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 791                                                 "[Error] set value of vconf fail.");
 792                         }
 793                         /*  Success to Operate */
 794                         bundle *b = NULL;
 795                         b = bundle_create();
 796                         if (!b)
 797                                 return;
 798                         bundle_add(b, "result", ad->view_type_string);
 799                         ug_send_result(ad->ug, b);
 800                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 801                         bundle_free(b);
 802                         /* Send destroy request */
 803                         ug_destroy_me(ad->ug);
 804                 }
 805                 break;
 806         case SIM_LOCK_INCORRECT_PASSWORD:
 807                 ad->focus_data = ad->ed_pw1;
 808                 setting_password_ug_check_attemps_left(ad);
 809                 break;
 810         case SIM_INCORRECT_PIN1_CODE:
 811                 {
 812                         const char *ret_str = NULL;
 813                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 814
 815                         if (result->retry_cnt > 1) {
 816                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 817                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 818                                 setting_retm_if(ret < 0, "snprintf fail");
 819                                 ret_str = tmp_str;
 820                         } else {
 821                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 822                         }
 823                         ad->focus_data = ad->ed_pw1;
 824                         setting_password_ug_display_desc(ad, (char *)ret_str, FALSE);
 825                 }
 826                 break;
 827         case SIM_INCORRECT_PIN2_CODE:
 828                 {
 829                         char *ret_str = NULL;
 830                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 831
 832                         if (result->retry_cnt > 1) {
 833                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 834                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 835                                 setting_retm_if(ret < 0, "snprintf fail");
 836                                 ret_str = tmp_str;
 837                         } else {
 838                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 839                         }
 840                         ad->focus_data = ad->ed_pw1;
 841                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 842                 }
 843                 break;
 844         case SIM_INCORRECT_PUK1_CODE:
 845                 {
 846                         char *ret_str = NULL;
 847                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 848
 849                         if (result->retry_cnt > 1) {
 850                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK1_PD_ATTEMPTS_LEFT', must transform */
 851                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK1_ERR_DESC, result->retry_cnt);
 852                                 setting_retm_if(ret < 0, "snprintf fail");
 853                                 ret_str = tmp_str;
 854                         } else {
 855                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK1_1_ATTEMPT_LEFT");
 856                         }
 857                         ad->focus_data = ad->ed_pw1;
 858                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 859                 }
 860                 break;
 861         case SIM_INCORRECT_PUK2_CODE:
 862                 {
 863                         char *ret_str = NULL;
 864                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 865                         if (result->retry_cnt > 1) {
 866                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK2_PD_ATTEMPTS_LEFT', must transform*/
 867                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK2_ERR_DESC, result->retry_cnt);
 868                                 setting_retm_if(ret < 0, "snprintf fail");
 869                                 ret_str = tmp_str;
 870                         } else {
 871                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK2_1_ATTEMPT_LEFT");
 872                         }
 873                         ad->focus_data = ad->ed_pw1;
 874                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 875                 }
 876                 break;
 877         case SIM_PIN1_CHANGE_SUCCESS:
 878                 setting_password_ug_create_popup_notitle_nobtn(ad,
 879                                                                _("IDS_ST_POP_PIN1_CHANGED"), TRUE);
 880                 break;
 881         case SIM_PIN2_CHANGE_SUCCESS:
 882                 setting_password_ug_create_popup_notitle_nobtn(ad,
 883                                                                _("IDS_ST_POP_PIN2_CHANGED"), TRUE);
 884                 break;
 885         case SIM_PIN1_BLOCKED:
 886                 setting_password_ug_create_popup_notitle_nobtn(ad,
 887                                                                _("IDS_ST_POP_PIN1_BLOCKED"), TRUE);
 888                 break;
 889         case SIM_PIN2_BLOCKED:
 890                 setting_password_ug_create_popup_notitle_nobtn(ad,
 891                                                                _("IDS_ST_POP_PIN2_BLOCKED"), TRUE);
 892                 break;
 893         case SIM_PIN1_UNBLOCKED:
 894                 setting_password_ug_create_popup_notitle_nobtn(ad,
 895                                                                _("IDS_ST_POP_PIN_UNBLOCKED"), TRUE);
 896                 break;
 897         case SIM_PIN2_UNBLOCKED:
 898                 setting_password_ug_create_popup_notitle_nobtn(ad,
 899                                                                _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
 900                 break;
 901         case SIM_PUK1_BLOCKED:
 902                 setting_password_ug_create_popup_notitle_nobtn(ad,
 903                                        _("IDS_ST_BODY_PUK1_BLOCKED"), TRUE);
 904                 /*  Call Permernent UG */
 905                 break;
 906         case SIM_PUK2_BLOCKED:
 907                 setting_password_ug_create_popup_notitle_nobtn(ad,
 908                                        _("IDS_ST_BODY_PUK2_BLOCKED"), TRUE);
 909                 /*  Call Permernent UG */
 910                 break;
 911         case SIM_REQUIRED_PUK_CODE:
 912                 break;
 913         case SIM_OPERATION_UNAVAILABLE:
 914                 setting_password_ug_create_popup_notitle_nobtn(ad,
 915                                        _("IDS_ST_POP_SERVICE_UNAVAILABLE"), TRUE);
 916                 break;
 917         case SIM_UNKNOWN_ERROR:
 918                 setting_password_ug_create_popup_notitle_nobtn(ad,
 919                                        _("IDS_ST_POP_UNKNOWN_OPERATION"), FALSE);
 920                 break;
 921         case SIM_ERROR:
 922         case SIM_REQ_PIN:
 923         case SIM_OPERATION_OFF:
 924         case SIM_LOCK_ON_FAIL:
 925         case SIM_PIN1_CHANGE_FAIL:
 926         case SIM_PIN2_CHANGE_FAIL:
 927                 break;
 928         default:
 929                 break;
 930         }
 931
 932         SETTING_TRACE_END;
 933 }
 934
 935 void setting_password_ug_popup_resp_cb(void *data, Evas_Object *obj,
 936                                        void *event_info)
 937 {
 938         retm_if(data == NULL, "Data parameter is NULL");
 939         bundle *b = NULL;
 940         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 941                         if (ad->destroy) {
 942                                 /*  Success to Operate */
 943                                 b = bundle_create();
 944                                 if (!b)
 945                                         return;
 946                                 bundle_add(b, "result", ad->view_type_string);
 947                                 ug_send_result(ad->ug, b);
 948                                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 949                                 bundle_free(b);
 950
 951                                 /* Send destroy request */
 952                                 ug_destroy_me(ad->ug);
 953                         } else {
 954                                 char *diable_view_type = NULL;
 955                                 if (ad->disable_item_type == SETTING_PW_TYPE_PHONE_LOCK) {
 956                                         diable_view_type = "SETTING_PW_TYPE_PHONE_LOCK_DISABLE";
 957                                 } else if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
 958                                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
 959                                 }
 960
 961                                 if (diable_view_type) {
 962                                         /*  Success to Operate */
 963                                         b = bundle_create();
 964                                         if (!b)
 965                                                 return;
 966                                         bundle_add(b, "result", diable_view_type);
 967                                         ug_send_result(ad->ug, b);
 968                                         bundle_free(b);
 969
 970                                         /* Send destroy request */
 971                                         ug_destroy_me(ad->ug);
 972                                 }
 973                                 if (ad->focus_data) {
 974                                         ad->focus_data->isFocusFlag = TRUE;
 975                                         elm_object_item_data_set(ad->focus_data->item, ad->focus_data);
 976                                         elm_genlist_item_update(ad->focus_data->item);
 977                                 }
 978                         }
 979                 }
 980 static Eina_Bool __remove_desc(void *data)
 981 {
 982         SETTING_TRACE_BEGIN;
 983         retv_if(data == NULL, EINA_FALSE);
 984
 985         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 986
 987         if(ad->err_desc)
 988         {
 989                 elm_object_item_del(ad->err_desc);
 990                 ad->err_desc = NULL;
 991         }
 992
 993         if(ad->remove_timer)
 994         {
 995                 ecore_timer_del(ad->remove_timer);
 996                 ad->remove_timer = NULL;
 997         }
 998
 999         if (ad->destroy) {
1000                 /*  Success to Operate */
1001                 bundle *b = bundle_create();
1002                 if (!b)
1003                         return EINA_FALSE;
1004                 bundle_add(b, "result", ad->view_type_string);
1005                 ug_send_result(ad->ug, b);
1006                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1007                 bundle_free(b);
1008
1009                 /* Send destroy request */
1010                 ug_destroy_me(ad->ug);
1011         } else {
1012                 char *diable_view_type = NULL;
1013                 if (ad->disable_item_type == SETTING_PW_TYPE_PHONE_LOCK) {
1014                         diable_view_type = "SETTING_PW_TYPE_PHONE_LOCK_DISABLE";
1015                 } else if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
1016                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
1017                 }
1018
1019                 if (diable_view_type) {
1020                         /*  Success to Operate */
1021                         bundle *b = bundle_create();
1022                         if (!b)
1023                                 return EINA_FALSE;
1024                         bundle_add(b, "result", diable_view_type);
1025                         ug_send_result(ad->ug, b);
1026                         bundle_free(b);
1027
1028                         /* Send destroy request */
1029                         ug_destroy_me(ad->ug);
1030                 }
1031         }
1032         return ECORE_CALLBACK_CANCEL;
1033 }
1034
1035 void setting_password_ug_display_desc(void *data, char *desc, int destroy)
1036 {
1037         SETTING_TRACE_BEGIN;
1038         ret_if(data == NULL || desc == NULL);
1039
1040         SettingPasswordUG *ad = (SettingPasswordUG *)data;
1041
1042         ad->destroy= destroy;
1043
1044         if(ad->scroller == NULL)
1045                 return;
1046
1047         if(ad->err_desc)
1048         {
1049                 elm_object_item_del(ad->err_desc);
1050                 ad->err_desc = NULL;
1051         }
1052
1053         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), desc, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1054         ad->remove_timer = ecore_timer_add(2.0, __remove_desc, ad);
1055
1056         /* if pw incorrect, show keyboard again. */
1057         if(ad->ed_pw1)
1058         {
1059                 SETTING_TRACE_DEBUG("FOCUS IN");
1060                 ad->ed_pw1->isFocusFlag = TRUE;
1061                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
1062         }
1063 }
1064
1065 void
1066 setting_password_ug_create_popup_notitle_nobtn(void *data, char *str,
1067                                                int destroy)
1068 {
1069         /* error check */
1070         retm_if(data == NULL, "Data parameter is NULL");
1071
1072         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1073
1074         ad->destroy = destroy;
1075         ad->notify = setting_create_popup_without_btn(ad, ad->ly_main, str,
1076                                           NULL,
1077                                           setting_password_ug_popup_resp_cb,
1078                                           POPUP_INTERVAL);
1079 }
1080
1081 void setting_password_ug_check_attemps_left(void *data)
1082 {
1083         ret_if(!data);
1084         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1085
1086         setting_int_slp_list item_attempts_left;
1087         setting_str_slp_list item_lock_timestamp;
1088         int attemps_left_max = 5;
1089
1090         if (ad->view_type == SETTING_PW_TYPE_PHONE_LOCK) {
1091                 item_attempts_left = INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT;
1092                 item_lock_timestamp = STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP;
1093                 attemps_left_max = PHONE_LOCK_ATTEMPS_MAX;
1094         } else if (ad->view_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
1095                 item_attempts_left = INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT;
1096                 item_lock_timestamp = STR_SLP_SETTING_SIM_LOCK_TIMESTAMP;
1097                 attemps_left_max = SIM_LOCK_ATTEMPS_MAX;
1098         } else {
1099                 return;
1100         }
1101
1102         int value = -1;
1103         int err = SETTING_RETURN_SUCCESS;
1104         setting_get_int_slp_key(item_attempts_left, &value, &err);
1105         setting_retm_if(err == SETTING_RETURN_FAIL,
1106                         "[Error] get value of vconf fail.");
1107
1108         value--;
1109
1110         if (value > 0 && value <= attemps_left_max) {
1111                 setting_set_int_slp_key(item_attempts_left, value, &err);
1112                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
1113                 char temp_str[MAX_SPECIALIZITION_LEN] = {0,};
1114                 char temp[MAX_SPECIALIZITION_LEN] ={0,};
1115
1116                 if(value > 1)
1117                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPTS_DESC);
1118                 else
1119                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPT_DESC);
1120
1121                 int ret = snprintf(temp_str, MAX_SPECIALIZITION_LEN, temp, value);
1122
1123                 ret_if(ret < 0);
1124
1125                 setting_password_ug_display_desc(ad, temp_str, FALSE);
1126
1127         } else if (value == 0) {
1128                 /*  store the lock timestamp */
1129                 time_t cur_time = time(NULL);
1130                 char cur_timestamp[LOCK_TIMESTAMP_LEN] = { 0, };
1131                 int ret = snprintf(cur_timestamp, sizeof(cur_timestamp), "%ld", cur_time);
1132                 ret_if(ret < 0);
1133
1134                 setting_set_string_slp_key(item_lock_timestamp, cur_timestamp, &err);
1135                 setting_retm_if(err == SETTING_RETURN_FAIL,
1136                                 "[Error] set value of vconf fail.");
1137
1138                 setting_set_int_slp_key(item_attempts_left, value, &err);
1139                 setting_retm_if(err == SETTING_RETURN_FAIL,
1140                                 "[Error] set value of vconf fail.");
1141
1142                 ad->disable_item_type = ad->view_type;
1143
1144                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
1145                 snprintf(temp, sizeof(temp), PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
1146
1147                 setting_password_ug_create_popup_notitle_nobtn(ad, temp, FALSE);
1148         } else {
1149                 setting_password_ug_create_popup_notitle_nobtn(ad,
1150                                                                _("IDS_COM_POP_ERROR"), FALSE);
1151         }
1152
1153 }
1154
1155 int setting_password_is_password_empty()
1156 {
1157         SETTING_TRACE_BEGIN;
1158         int ret = 0;
1159         unsigned int attempt = 0;
1160         unsigned int max_attempt = 0;
1161         unsigned int expire_sec = 0;
1162
1163         ret = security_server_is_pwd_valid(&attempt, &max_attempt, &expire_sec);
1164         SETTING_TRACE_DEBUG("status of password : %d", ret);
1165
1166         if(ret == SECURITY_SERVER_API_ERROR_NO_PASSWORD)
1167                 return SETTING_RETURN_SUCCESS;
1168         else
1169                 return SETTING_RETURN_FAIL;
1170 }
1171 int setting_password_check_password(const char *challenge)
1172 {
1173         SETTING_TRACE_BEGIN;
1174         retv_if(challenge == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1175
1176         int ret = 0;
1177         unsigned int current_attempt = 0;
1178         unsigned int max_attempt = 0;
1179         unsigned int valid_secs = 0;
1180
1181         ret = security_server_chk_pwd(challenge, &current_attempt, &max_attempt, &valid_secs);
1182
1183         SETTING_TRACE_DEBUG("chk password : %d", ret);
1184
1185         if(ret == SECURITY_SERVER_API_SUCCESS)
1186                 return SETTING_RETURN_SUCCESS;
1187         else
1188                 return SETTING_RETURN_FAIL;
1189 }
1190 int setting_password_set_password(const char *cur_pwd, const char *new_pwd, void *data)
1191 {
1192         SETTING_TRACE_BEGIN;
1193         retv_if(new_pwd == NULL || data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1194
1195         SettingPasswordUG *ad = (SettingPasswordUG*)data;
1196         int ret = 0;
1197
1198         /* max attempt count will be handled in passwordug for a while. */
1199         ret = security_server_set_pwd(cur_pwd, new_pwd, 0, PW_ERR_DELAY_TIME);
1200         SETTING_TRACE_DEBUG("set password : %d", ret);
1201
1202         if(ret == SECURITY_SERVER_API_SUCCESS)
1203                 return SETTING_RETURN_SUCCESS;
1204         else
1205                 return SETTING_RETURN_FAIL;
1206 }