setting-password/src/setting-password-sim.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-sim.h>
  24 #include <setting-common-data-slp-setting.h>
  25 #include <setting-debug.h>
  26 #include <dd-haptic.h>
  27 #include <Ecore_IMF.h>
  28 #include <Ecore_IMF_Evas.h>
  29 #include <Ecore_X.h>
  30 #include <Ecore.h>
  31 #include <utilX.h>
  32 #include <time.h>
  33 #include <notification.h>
  34
  35 static int setting_password_sim_create(void *cb);
  36 static int setting_password_sim_destroy(void *cb);
  37 static int setting_password_sim_update(void *cb);
  38 static int setting_password_sim_cleanup(void *cb);
  39
  40 setting_view setting_view_password_sim = {
  41         .create = setting_password_sim_create,
  42         .destroy = setting_password_sim_destroy,
  43         .update = setting_password_sim_update,
  44         .cleanup = setting_password_sim_cleanup,
  45 };
  46
  47 static void setting_password_sim_done(void *data);
  48
  49
  50 /* ***************************************************
  51  *
  52  *basic func
  53  *
  54  ***************************************************/
  55 static void
  56 __password_sim_gl_mouse_up(void *data, Evas *e, Evas_Object *obj,
  57                             void *event)
  58 {
  59         ret_if(!data);
  60         //SettingPasswordUG *ad = (SettingPasswordUG *) data;
  61
  62         /* P131121-05156 : do not hide input panel when genlist scrolls,
  63                                                 plz compare with [about device > device name] item */
  64 }
  65
  66 static char *setting_password_sim_get_title_str(void *data)
  67 {
  68         retvm_if(data == NULL, NULL,
  69                  "[Setting > Password] Data parameter is NULL");
  70         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  71
  72         switch (ad->view_type) {
  73         case SETTING_PW_TYPE_SIM_LOCK_ON:
  74         case SETTING_PW_TYPE_SIM_LOCK_OFF:
  75                 return "IDS_COM_BODY_AUTH_PASSWORD";
  76                 break;
  77         case SETTING_PW_TYPE_PIN_LOCK_ON:
  78         case SETTING_PW_TYPE_PIN_LOCK_OFF:
  79                 return _("IDS_ST_BODY_PIN");
  80                 break;
  81         case SETTING_PW_TYPE_CHANGE_PIN:
  82                 return _("IDS_ST_HEADER_CHANGE_PIN_ABB");
  83                 break;
  84
  85         case SETTING_PW_TYPE_CHANGE_PIN2:
  86                 return _("IDS_ST_BODY_CHANGE_PIN2");
  87                 break;
  88
  89         case SETTING_PW_TYPE_PIN_BLOCKED:
  90                 return _("IDS_ST_BODY_PUK1_CODE");
  91                 break;
  92         case SETTING_PW_TYPE_PIN2_BLOCKED:
  93
  94                 return _("IDS_ST_BODY_PUK2");
  95                 break;
  96         default:
  97                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
  98                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
  99                 break;
 100         }
 101         return NULL;
 102
 103 }
 104
 105 static Eina_Bool setting_password_sim_click_softkey_cancel_cb(void *data, Elm_Object_Item *it)
 106 {
 107         SETTING_TRACE_BEGIN;
 108         /* error check */
 109         retvm_if(data == NULL, EINA_FALSE, "[Setting > Password] Data parameter is NULL");
 110
 111         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 112 #if 0
 113         // if IME is displayed, hide IME. or Destroy password ug.
 114         if(ad->ed_pw1 && ad->ed_pw1->isFocusFlag == TRUE && elm_object_focus_get(ad->ed_pw1->eo_check))
 115         {
 116                 SETTING_TRACE_DEBUG("wait to hide IME");
 117                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_FALSE);
 118                 return EINA_FALSE;
 119         }
 120         else if(ad->ed_pw2 && ad->ed_pw2->isFocusFlag == TRUE && elm_object_focus_get(ad->ed_pw2->eo_check))
 121         {
 122                 SETTING_TRACE_DEBUG("wait to hide IME");
 123                 elm_object_focus_set(ad->ed_pw2->eo_check, EINA_FALSE);
 124                 return EINA_FALSE;
 125         }
 126         else if(ad->ed_pw3 && ad->ed_pw3->isFocusFlag == TRUE && elm_object_focus_get(ad->ed_pw3->eo_check))
 127         {
 128                 SETTING_TRACE_DEBUG("wait to hide IME");
 129                 elm_object_focus_set(ad->ed_pw3->eo_check, EINA_FALSE);
 130                 return EINA_FALSE;
 131         }
 132 #endif
 133         if (ad->focus_timer) {
 134                 ecore_timer_del(ad->focus_timer);
 135                 ad->focus_timer = NULL;
 136         }
 137
 138         /* send result : Cancel */
 139         app_control_h svc;
 140         if(app_control_create(&svc) == 0)
 141         {
 142                 app_control_add_extra_data(svc, "result", "Cancel");
 143                 ug_send_result(ad->ug, svc);
 144                 SETTING_TRACE("Send Result : %s\n", "Cancel");
 145
 146                 app_control_destroy(svc);
 147         }
 148         /* Send destroy request */
 149         ug_destroy_me(ad->ug);
 150
 151         return EINA_TRUE;
 152 }
 153
 154 static int __create_sim_layout(void *data)
 155 {
 156         SETTING_TRACE_BEGIN;
 157         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 158
 159         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 160         static int count = 0;
 161
 162         count++;
 163         /* CONTENT */
 164         if(ad->scroller != NULL)
 165         {
 166                 evas_object_del(ad->scroller);
 167                 ad->scroller = NULL;
 168         }
 169
 170         /* PIN related views have 2 toolbar buttons. CANCEL and DONE button */
 171         ad->ly_main = setting_create_layout_navi_bar_genlist(ad->win_main_layout, ad->win_get, setting_password_sim_get_title_str(ad),
 172                                                                                         _("IDS_COM_BODY_BACK"),
 173                                                                                         NULL,
 174                                                                                         (setting_call_back_func)setting_password_sim_click_softkey_cancel_cb,
 175                                                                                         NULL,
 176                                                                                         ad,
 177                                                                                         &(ad->scroller),
 178                                                                                         &(ad->navi_bar));
 179
 180         ad->navi_it = elm_naviframe_top_item_get(ad->navi_bar);
 181         ad->bottom_btn = elm_button_add(ad->navi_bar);
 182
 183         Evas_Object *btn_cancel = elm_button_add(ad->navi_bar);
 184         elm_object_style_set(btn_cancel, "naviframe/title_cancel");
 185         evas_object_smart_callback_add(btn_cancel, "clicked", setting_password_sim_click_softkey_cancel_cb, ad);
 186         elm_object_item_part_content_set(ad->navi_it, "title_left_btn", btn_cancel);
 187
 188         Evas_Object *btn_done = elm_button_add(ad->navi_bar);
 189         elm_object_style_set(btn_done, "naviframe/title_done");
 190         evas_object_smart_callback_add(btn_done, "clicked", setting_password_sim_click_softkey_done_cb, ad);
 191         elm_object_item_part_content_set(ad->navi_it, "title_right_btn", btn_done);
 192
 193         if(!ad->scroller)
 194         {
 195                 SETTING_TRACE("genlist is NULL");
 196                 return SETTING_RETURN_FAIL;
 197         }
 198
 199         /* Disable Done button if exist */
 200         elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 201         elm_object_focus_allow_set(ad->bottom_btn, EINA_FALSE);
 202         elm_object_item_signal_emit(ad->navi_it, "elm,state,sip,shown","");
 203
 204         elm_genlist_mode_set(ad->scroller, ELM_LIST_COMPRESS);
 205         //evas_object_smart_callback_add(ad->scroller, "drag", __password_main_gl_drag, ad);
 206         evas_object_event_callback_add(ad->scroller, EVAS_CALLBACK_MOUSE_UP,
 207                                        __password_sim_gl_mouse_up, ad);
 208
 209         ADD_GL_SEPARATOR(ad->scroller)
 210
 211         return SETTING_RETURN_SUCCESS;
 212 }
 213
 214 static Eina_Bool __setting_password_sim_rotate_cb(void *data)
 215 {
 216         /* error check */
 217         SETTING_TRACE_BEGIN;
 218         retv_if(data == NULL, FALSE);
 219
 220         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 221
 222         if(ad->view_type == SETTING_PW_TYPE_PIN_LOCK_OFF
 223                 || ad->view_type == SETTING_PW_TYPE_PIN_LOCK_ON
 224                 || ((ad->view_type == SETTING_PW_TYPE_CHANGE_PIN) && !ad->cur_pwd)
 225                 || ad->view_type == SETTING_PW_TYPE_PIN_BLOCKED)
 226         {
 227                 if(tel_get_sim_lock_info(ad->handle, TAPI_SIM_LOCK_SC, setting_get_pin_lock_info_cb, ad) != 0)
 228                         SETTING_TRACE_DEBUG("failed to call tel_get_sim_lock_info()");
 229         }
 230         else if(((ad->view_type == SETTING_PW_TYPE_CHANGE_PIN2) && !ad->cur_pwd)
 231                 || ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
 232         {
 233                 if(tel_get_sim_lock_info(ad->handle, TAPI_SIM_LOCK_FD, setting_get_pin_lock_info_cb, ad) != 0)
 234                         SETTING_TRACE_DEBUG("failed to call tel_get_sim_lock_info()");
 235         }
 236
 237         // it can manage the cursor self
 238         if(ad->ed_pw1 && ad->ed_pw1->isFocusFlag)
 239         {
 240                 if (ad->ed_pw1->eo_check)
 241                 {
 242                         SETTING_TRACE_DEBUG("set focus on first entry");
 243                         // no matter how many edifileds, it only need focus on 1st editfiled
 244                         elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 245                         elm_entry_cursor_end_set(ad->ed_pw1->eo_check);
 246                 }
 247         }
 248         else if(ad->ed_pw2 && ad->ed_pw2->isFocusFlag)
 249         {
 250                 if (ad->ed_pw2->eo_check)
 251                 {
 252                         SETTING_TRACE_DEBUG("set focus on second entry");
 253                         //no matter how many edifileds, it only need focus on 1st editfiled
 254                         elm_object_focus_set(ad->ed_pw2->eo_check, EINA_TRUE);
 255                         elm_entry_cursor_end_set(ad->ed_pw2->eo_check);
 256                 }
 257         }
 258         else if(ad->ed_pw3 && ad->ed_pw3->isFocusFlag)
 259         {
 260                 if (ad->ed_pw3->eo_check)
 261                 {
 262                         SETTING_TRACE_DEBUG("set focus on third entry");
 263                         //no matter how many edifileds, it only need focus on 1st editfiled
 264                         elm_object_focus_set(ad->ed_pw3->eo_check, EINA_TRUE);
 265                         elm_entry_cursor_end_set(ad->ed_pw3->eo_check);
 266                 }
 267         }
 268
 269         ad->focus_timer = NULL;
 270
 271         return ECORE_CALLBACK_CANCEL;
 272 }
 273
 274 static void __init_tapi(SettingPasswordUG *ad)
 275 {
 276         ad->handle =  tel_init(NULL);
 277         if (!ad->handle) {
 278                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_init. ***%s",
 279                              SETTING_FONT_RED, SETTING_FONT_BLACK);
 280                 setting_password_ug_create_popup_notitle_nobtn(ad,
 281                                                                        _("IDS_COM_POP_ERROR"),
 282                                                                        FALSE);
 283         }
 284 }
 285
 286 static void __deinit_tapi(SettingPasswordUG *ad)
 287 {
 288         if(ad->handle)
 289         {
 290                 if (tel_deinit(ad->handle) != TAPI_API_SUCCESS) {
 291                         SETTING_TRACE_DEBUG("%s*** [ERR] setting_network_unsubscribe_tapi_events. ***%s",
 292                                                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
 293                         setting_password_ug_create_popup_notitle_nobtn(ad,
 294                                                                        _("IDS_COM_POP_ERROR"),
 295                                                                        FALSE);
 296                 }
 297                 ad->handle = NULL;
 298         }
 299 }
 300
 301 static int setting_password_sim_create(void *cb)
 302 {
 303         SETTING_TRACE_BEGIN;
 304         /* error check */
 305         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 306
 307         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 308         int ret = 0;
 309
 310         ret = __create_sim_layout(ad);
 311
 312         if(ret < 0)
 313                 return SETTING_RETURN_FAIL;
 314
 315         __init_tapi(ad);
 316
 317         setting_password_sim_create_ui(ad);
 318
 319         ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
 320
 321         setting_view_password_sim.is_create = 1;
 322
 323         SETTING_TRACE_END;
 324         return SETTING_RETURN_SUCCESS;
 325 }
 326
 327 static int setting_password_sim_destroy(void *cb)
 328 {
 329         SETTING_TRACE_BEGIN;
 330         /* error check */
 331         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 332
 333         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 334
 335         __deinit_tapi(ad);
 336
 337         if (ad->remove_timer) {
 338                 ecore_timer_del(ad->remove_timer);
 339                 ad->remove_timer = NULL;
 340         }
 341         if(ad->notify)
 342         {
 343                 evas_object_del(ad->notify);
 344                 ad->notify = NULL;
 345         }
 346         //FREE(ad->guide_str);
 347
 348         if (ad->ly_main != NULL) {
 349                 evas_object_del(ad->ly_main);
 350                 ad->ly_main = NULL;
 351                 setting_view_password_sim.is_create = 0;
 352         }
 353         SETTING_TRACE_END;
 354         return SETTING_RETURN_SUCCESS;
 355 }
 356
 357 static int setting_password_sim_update(void *cb)
 358 {
 359         SETTING_TRACE_BEGIN;
 360         /* error check */
 361         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 362
 363         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 364
 365         if (ad->ly_main != NULL) {
 366                 evas_object_show(ad->ly_main);
 367         }
 368         if(ad->puk_verified_flag == TRUE && ad->view_type == SETTING_PW_TYPE_PIN_BLOCKED)
 369         {
 370                 ad->puk_verified_flag = FALSE;
 371                 SETTING_TRACE_DEBUG("view type : PIN1_BLOCKED, change view");
 372                 if(ad->scroller)
 373                 {
 374                         elm_genlist_clear(ad->scroller);
 375                         ADD_GL_SEPARATOR(ad->scroller)
 376                         if(ad->cur_pwd)
 377                         {
 378                                 setting_password_sim_draw_2line_entry(ad, NULL);
 379                         }
 380                         else
 381                         {
 382                                 setting_password_sim_draw_1line_entry(ad, NULL);
 383                                 ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
 384                         }
 385                 }
 386         }
 387         return SETTING_RETURN_SUCCESS;
 388 }
 389
 390 static int setting_password_sim_cleanup(void *cb)
 391 {
 392         /* error check */
 393         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 394
 395         SettingPasswordUG *ad = (SettingPasswordUG *) cb;
 396
 397         if (ad->ly_main != NULL) {
 398                 evas_object_hide(ad->ly_main);
 399         }
 400
 401         return SETTING_RETURN_SUCCESS;
 402 }
 403
 404 /* ***************************************************
 405  *
 406  *general func
 407  *
 408  ***************************************************/
 409
 410 int setting_password_sim_create_ui(void *data)
 411 {
 412         /* error check */
 413         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 414                  "[Setting > Password] Data parameter is NULL");
 415
 416         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 417
 418         SETTING_TRACE_DEBUG("ad->view_type=%d ***", ad->view_type);
 419
 420         switch (ad->view_type) {
 421         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 422         case SETTING_PW_TYPE_PIN_LOCK_ON:
 423         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 424         case SETTING_PW_TYPE_PIN_BLOCKED:
 425         case SETTING_PW_TYPE_CHANGE_PIN:
 426         case SETTING_PW_TYPE_CHANGE_PIN2:
 427                 setting_password_sim_draw_1line_entry(ad, NULL);
 428                 break;
 429         case SETTING_PW_TYPE_SIM_LOCK_ON:
 430                 setting_password_sim_draw_2line_entry(ad, NULL);
 431                 break;
 432         case SETTING_PW_TYPE_PIN2_BLOCKED:
 433                 setting_password_sim_draw_3line_entry(ad, NULL);
 434                 break;
 435         default:
 436                 SETTING_TRACE_DEBUG("%s*** Unknown Password Type. ***%s",
 437                                     SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 438                 break;
 439         }
 440
 441         /** @todo this function always return 0, not verifying the function flow with the value */
 442         return 0;
 443 }
 444
 445 static void
 446 setting_password_sim_entry_changed_cb(void *data, Evas_Object *obj,
 447                                        void *event_info)
 448 {
 449         SETTING_TRACE_BEGIN;
 450         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
 451         retm_if(obj == NULL, "[Setting > Password] Data parameter is NULL");
 452         Setting_GenGroupItem_Data *list_item =
 453             (Setting_GenGroupItem_Data *) data;
 454         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 455         const char *entry_str = elm_entry_entry_get(obj);
 456         list_item->sub_desc = (char *)g_strdup(entry_str);
 457         bool isFoundEmptyEntry = FALSE;
 458
 459         elm_object_part_text_set(obj, "elm.guide", "");
 460
 461         do {
 462                 if (ad->ed_pw1) {
 463                         entry_str = ad->ed_pw1->sub_desc;
 464                         if (NULL == entry_str || '\0' == entry_str[0]) {
 465                                 isFoundEmptyEntry = TRUE;
 466                                 elm_object_part_text_set(obj, "elm.guide", _("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 467                                 elm_object_item_signal_emit(ad->ed_pw1->item, "elm,state,eraser,hide", "");
 468                                 break;
 469                         }
 470                         else if(ad->ed_pw1->isFocusFlag)
 471                         {
 472                                 elm_object_item_signal_emit(ad->ed_pw1->item, "elm,state,eraser,show", "");
 473                                 break;
 474                         }
 475                 }
 476                 if (ad->ed_pw2) {
 477                         entry_str = ad->ed_pw2->sub_desc;
 478                         if (NULL == entry_str || '\0' == entry_str[0]) {
 479                                 isFoundEmptyEntry = TRUE;
 480                                 elm_object_part_text_set(obj, "elm.guide", _("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 481                                 elm_object_item_signal_emit(ad->ed_pw2->item, "elm,state,eraser,hide", "");
 482                                 break;
 483                         }
 484                         else if(ad->ed_pw2->isFocusFlag)
 485                         {
 486                                 elm_object_item_signal_emit(ad->ed_pw2->item, "elm,state,eraser,show", "");
 487                                 break;
 488                         }
 489                 }
 490                 if (ad->ed_pw3) {
 491                         entry_str = ad->ed_pw3->sub_desc;
 492                         if (NULL == entry_str || '\0' == entry_str[0]) {
 493                                 isFoundEmptyEntry = TRUE;
 494                                 elm_object_part_text_set(obj, "elm.guide", _("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 495                                 elm_object_item_signal_emit(ad->ed_pw3->item, "elm,state,eraser,hide", "");
 496                                 break;
 497                         }
 498                         else if(ad->ed_pw3->isFocusFlag)
 499                         {
 500                                 elm_object_item_signal_emit(ad->ed_pw3->item, "elm,state,eraser,show", "");
 501                                 break;
 502                         }
 503                 }
 504
 505         } while (0);
 506
 507         Eina_Bool item_disabled = elm_object_item_disabled_get(list_item->item);
 508         if(item_disabled)
 509                 return;
 510
 511         /* For disable toolbar (done) item */
 512         bool disableFlag = isFoundEmptyEntry;
 513         if(ad->view_type == SETTING_PW_TYPE_PIN_BLOCKED
 514                 || ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
 515         {
 516                 if(ad->ed_pw1) {
 517                         if(!ad->cur_pwd && ad->ed_pw1->eo_check && (safeStrLen(elm_entry_entry_get(ad->ed_pw1->eo_check)) < 8))
 518                         {
 519                                 SETTING_TRACE_DEBUG("disable flag becomes TRUE");
 520                                 disableFlag = TRUE;
 521                         }
 522                 }
 523         }
 524         else
 525         {
 526                 if(ad->ed_pw1 && ad->ed_pw1->eo_check && (safeStrLen(elm_entry_entry_get(ad->ed_pw1->eo_check)) < 4))
 527                         disableFlag = TRUE;
 528                 if(ad->ed_pw2 && ad->ed_pw2->eo_check && (safeStrLen(elm_entry_entry_get(ad->ed_pw2->eo_check)) < 4))
 529                         disableFlag = TRUE;
 530                 if(ad->ed_pw3 && ad->ed_pw3->eo_check && (safeStrLen(elm_entry_entry_get(ad->ed_pw3->eo_check)) < 4))
 531                         disableFlag = TRUE;
 532         }
 533
 534         if (disableFlag) {
 535                 elm_object_disabled_set(ad->bottom_btn, EINA_TRUE);
 536         } else {
 537                 elm_object_disabled_set(ad->bottom_btn, EINA_FALSE);
 538                 if(ad->err_desc && ad->err_desc->item)
 539                 {
 540                         elm_object_item_del(ad->err_desc->item);
 541                         ad->err_desc = NULL;
 542                 }
 543         }
 544 }
 545
 546 #if 0
 547 static void __reached_max_pwlength_cb(void *data, Evas_Object *obj, void *event_info)
 548 {
 549         SETTING_TRACE_BEGIN;
 550         retm_if(data == NULL, "Data parameter is NULL");
 551         retm_if(!elm_object_focus_get(obj), "Entry is not focused");//notify only when entry is being focused on.
 552
 553         int err = 0;
 554
 555         //Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 556         //SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 557
 558         int haptic_return = 0;
 559         haptic_device_h haptic_handle;
 560         haptic_return = haptic_open(HAPTIC_DEVICE_0, &haptic_handle);
 561         SETTING_TRACE("haptic_handle : %d", haptic_handle);
 562         if (haptic_return < 0) {
 563                 SETTING_TRACE_DEBUG("%s*** [ERR] Failed haptic_open ***%s",
 564                                                         SETTING_FONT_RED, SETTING_FONT_BLACK);
 565         }
 566
 567         err = haptic_vibrate_file_with_detail(haptic_handle, "/usr/share/feedback/haptic/touch/touch.ivt", 1, HAPTIC_FEEDBACK_AUTO, HAPTIC_PRIORITY_MIN, NULL);
 568
 569         if (err < 0)
 570                 SETTING_TRACE("Failed to play haptic");
 571
 572         haptic_close(haptic_handle);
 573 }
 574 #endif
 575
 576 static void __entry_activated_cb(void *data, Evas_Object *obj, void *event_info)
 577 {
 578         SETTING_TRACE_BEGIN;
 579         retm_if(data == NULL, "Data parameter is NULL");
 580
 581         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 582         SettingPasswordUG *ad = (SettingPasswordUG *) list_item->userdata;
 583
 584         if(elm_object_disabled_get(ad->bottom_btn) == EINA_FALSE)
 585         {
 586                 elm_object_focus_set(obj, EINA_FALSE);
 587                 // call done cb.
 588                 setting_password_sim_done(ad);
 589         }
 590
 591         if(obj == ad->ed_pw1->eo_check)
 592         {
 593                 if(ad->view_type == SETTING_PW_TYPE_PIN_BLOCKED
 594                         || ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
 595                 {
 596                         /* PUK should be 8 chars always */
 597                         if(safeStrLen(elm_entry_entry_get(ad->ed_pw1->eo_check)) < SETTING_PW_UG_PUK_MAX_LENGTH)
 598                         {
 599                                 SETTING_TRACE_DEBUG("do not move focus to next entry.");
 600                                 ad->ed_pw1->isFocusFlag = TRUE;
 601                                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 602                                 return;
 603                         }
 604                 }
 605                 if(ad->ed_pw2 && ad->ed_pw2->eo_check)
 606                 {
 607                         elm_object_focus_set(ad->ed_pw2->eo_check, EINA_TRUE);
 608                         ad->ed_pw2->isFocusFlag = TRUE;
 609                 }
 610         }
 611         else if(obj == ad->ed_pw2->eo_check)
 612         {
 613                 if(ad->ed_pw3 && ad->ed_pw3->eo_check)
 614                 {
 615                         elm_object_focus_set(ad->ed_pw3->eo_check, EINA_TRUE);
 616                         ad->ed_pw3->isFocusFlag = TRUE;
 617                 }
 618         }
 619 }
 620
 621 static void __entry_focused_cb(void *data, Evas_Object *obj, void *event_info)
 622 {
 623         SETTING_TRACE_BEGIN;
 624         retm_if(data == NULL, "Data parameter is NULL");
 625
 626         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 627         SettingPasswordUG *ad = (SettingPasswordUG*)list_item->userdata;
 628
 629         if(!elm_entry_is_empty(obj))
 630         {
 631                 elm_object_item_signal_emit(list_item->item, "elm,state,eraser,show", "");
 632         }
 633         elm_object_item_signal_emit(list_item->item, "elm,state,rename,hide", "");
 634
 635         if(ad == NULL)
 636                 return;
 637
 638         if(ad->ed_pw1 && obj == ad->ed_pw1->eo_check)
 639         {
 640                 ad->ed_pw1->isFocusFlag = TRUE;
 641                 if(ad->ed_pw2)
 642                         ad->ed_pw2->isFocusFlag = FALSE;
 643                 if(ad->ed_pw3)
 644                         ad->ed_pw3->isFocusFlag = FALSE;
 645         }
 646         else if(ad->ed_pw2 && obj == ad->ed_pw2->eo_check)
 647         {
 648                 ad->ed_pw2->isFocusFlag = TRUE;
 649                 if(ad->ed_pw1)
 650                         ad->ed_pw1->isFocusFlag = FALSE;
 651                 if(ad->ed_pw3)
 652                         ad->ed_pw3->isFocusFlag = FALSE;
 653         }
 654         else if(ad->ed_pw3 && obj == ad->ed_pw3->eo_check)
 655         {
 656                 ad->ed_pw3->isFocusFlag = TRUE;
 657                 if(ad->ed_pw1)
 658                         ad->ed_pw1->isFocusFlag = FALSE;
 659                 if(ad->ed_pw2)
 660                         ad->ed_pw2->isFocusFlag = FALSE;
 661         }
 662 }
 663
 664 static void __entry_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
 665 {
 666         SETTING_TRACE_BEGIN;
 667         retm_if(data == NULL, "Data parameter is NULL");
 668         retm_if(obj == NULL, "Data parameter is NULL");
 669
 670         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 671
 672         list_item->isFocusFlag = FALSE;
 673
 674         if(list_item->item)
 675         {
 676                 elm_object_item_signal_emit(list_item->item, "elm,state,eraser,hide", "");
 677                 elm_object_item_signal_emit(list_item->item, "elm,state,rename,show", "");
 678         }
 679 }
 680
 681 int setting_password_sim_draw_1line_entry(void *data, void *cb)
 682 {
 683         SETTING_TRACE_BEGIN;
 684         /* error check */
 685         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 686                  "[Setting > Password] Data parameter is NULL");
 687
 688         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 689
 690         switch (ad->view_type) {
 691         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 692                 ad->ed_pw1 =
 693                     setting_create_Gendial_field_editfield(ad->scroller,
 694                                                        &(itc_editfield),
 695                                                        NULL, ad,
 696                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 697                                                        "IDS_ST_BODY_SIM_PASSWORD",
 698                                                        NULL,
 699                                                        setting_password_sim_entry_changed_cb,
 700                                                        __entry_focused_cb,
 701                                                        __entry_unfocused_cb,
 702                                                        NULL,
 703                                                        NULL,
 704                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 705                                                        TRUE, TRUE,
 706                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
 707                                                        0, "0123456789", NULL);
 708                 break;
 709
 710         case SETTING_PW_TYPE_PIN_LOCK_ON:
 711         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 712                 ad->ed_pw1 =
 713                     setting_create_Gendial_field_editfield(ad->scroller,
 714                                                            &(itc_editfield),
 715                                                        NULL, ad,
 716                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 717                                                        "IDS_ST_BODY_PIN", NULL,
 718                                                        setting_password_sim_entry_changed_cb,
 719                                                        __entry_focused_cb,
 720                                                        __entry_unfocused_cb,
 721                                                        __entry_activated_cb,
 722                                                        NULL,
 723                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 724                                                        TRUE, TRUE,
 725                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 726                                                        0, "0123456789", NULL);
 727                 if(ad->ed_pw1)
 728                         ad->ed_pw1->guide_text = (char *)g_strdup(_("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 729                 break;
 730         case SETTING_PW_TYPE_PIN_BLOCKED:
 731                 ad->ed_pw1 =
 732                     setting_create_Gendial_field_editfield(ad->scroller,
 733                                                        &(itc_editfield),
 734                                                        NULL, ad,
 735                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 736                                                        "IDS_ST_BODY_PUK1_CODE",
 737                                                        NULL,
 738                                                        setting_password_sim_entry_changed_cb,
 739                                                        __entry_focused_cb,
 740                                                        __entry_unfocused_cb,
 741                                                        __entry_activated_cb,
 742                                                        NULL,
 743                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 744                                                        TRUE, TRUE,
 745                                                        SETTING_PW_UG_PUK_MAX_LENGTH,
 746                                                        0, "0123456789", NULL);
 747                 break;
 748         case SETTING_PW_TYPE_CHANGE_PIN:
 749         case SETTING_PW_TYPE_CHANGE_PIN2:
 750                 ad->ed_pw1 =
 751                     setting_create_Gendial_field_editfield(ad->scroller,
 752                                                        &(itc_editfield),
 753                                                        NULL, ad,
 754                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 755                                                        PW_SHORT_GUIDE_CURRENT,
 756                                                        NULL,
 757                                                        setting_password_sim_entry_changed_cb,
 758                                                        __entry_focused_cb,
 759                                                        __entry_unfocused_cb,
 760                                                        __entry_activated_cb,
 761                                                        NULL,
 762                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 763                                                        TRUE, TRUE,
 764                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 765                                                        0, "0123456789", NULL);
 766                 if(ad->ed_pw1)
 767                         ad->ed_pw1->guide_text = (char *)g_strdup(_("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 768                 break;
 769         default:
 770                 break;
 771         }
 772
 773         ad->ed_pw2 = NULL;
 774         ad->ed_pw3 = NULL;
 775         ad->cur_pwd = NULL;
 776
 777         return 0;
 778 }
 779
 780 int setting_password_sim_clear_1line_entry(void *data)
 781 {
 782         /* error check */
 783         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 784                  "[Setting > Password] Data parameter is NULL");
 785
 786         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 787         retv_if(NULL == ad->ed_pw1, -1);
 788
 789         ad->ed_pw1->sub_desc = NULL;
 790         ad->ed_pw1->isFocusFlag = FALSE;
 791
 792         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
 793         elm_object_part_text_set(ad->ed_pw1->eo_check, "elm.guide", _("Enter PIN"));
 794
 795         return 0;
 796 }
 797
 798 int setting_password_sim_draw_2line_entry(void *data, void *cb)
 799 {
 800         /* error check */
 801         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 802
 803         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 804
 805         switch (ad->view_type) {
 806         case SETTING_PW_TYPE_SIM_LOCK_ON:
 807                 ad->ed_pw1 =
 808                     setting_create_Gendial_field_editfield(ad->scroller,
 809                                                        &(itc_editfield),
 810                                                        NULL, ad,
 811                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 812                                                        PW_SHORT_GUIDE_NEW,
 813                                                        NULL,
 814                                                        setting_password_sim_entry_changed_cb,
 815                                                        __entry_focused_cb,
 816                                                        __entry_unfocused_cb,
 817                                                        __entry_activated_cb,
 818                                                        NULL,
 819                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 820                                                        TRUE, TRUE,
 821                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
 822                                                        0, "0123456789", NULL);
 823
 824                 ad->ed_pw2 =
 825                     setting_create_Gendial_field_editfield(ad->scroller,
 826                                                        &(itc_editfield),
 827                                                        NULL, ad,
 828                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 829                                                        PW_SHORT_GUIDE_CONFIRM,
 830                                                        NULL,
 831                                                        setting_password_sim_entry_changed_cb,
 832                                                        __entry_focused_cb,
 833                                                        __entry_unfocused_cb,
 834                                                        NULL,
 835                                                        NULL,
 836                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 837                                                        TRUE, FALSE,
 838                                                        SETTING_PW_UG_SIM_MAX_LENGTH,
 839                                                        0, "0123456789", NULL);
 840                 break;
 841         case SETTING_PW_TYPE_PIN_BLOCKED:
 842         case SETTING_PW_TYPE_CHANGE_PIN:
 843         case SETTING_PW_TYPE_CHANGE_PIN2:
 844                 ad->ed_pw1 =
 845                     setting_create_Gendial_field_editfield(ad->scroller,
 846                                                        &(itc_editfield),
 847                                                        NULL, ad,
 848                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 849                                                        PW_SHORT_GUIDE_NEW,
 850                                                        NULL,
 851                                                        setting_password_sim_entry_changed_cb,
 852                                                        __entry_focused_cb,
 853                                                        __entry_unfocused_cb,
 854                                                        __entry_activated_cb,
 855                                                        NULL,
 856                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 857                                                        TRUE, TRUE,
 858                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 859                                                        0, "0123456789", NULL);
 860                 if(ad->ed_pw1)
 861                         ad->ed_pw1->guide_text = (char *)g_strdup(_("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 862
 863                 ad->ed_pw2 =
 864                     setting_create_Gendial_field_editfield(ad->scroller,
 865                                                        &(itc_editfield),
 866                                                        NULL, ad,
 867                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 868                                                        PW_SHORT_GUIDE_CONFIRM,
 869                                                        NULL,
 870                                                        setting_password_sim_entry_changed_cb,
 871                                                        __entry_focused_cb,
 872                                                        __entry_unfocused_cb,
 873                                                        __entry_activated_cb,
 874                                                        NULL,
 875                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 876                                                        TRUE, FALSE,
 877                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 878                                                        0, "0123456789", NULL);
 879                 if(ad->ed_pw2)
 880                         ad->ed_pw2->guide_text = (char *)g_strdup(_("IDS_ST_HEADER_ENTER_PIN_ABB3"));
 881                 break;
 882         default:
 883                 break;
 884         }
 885
 886         if(ad->ed_pw1)
 887         {
 888                 ad->ed_pw1->group_style = SETTING_GROUP_STYLE_TOP;
 889         }
 890         if(ad->ed_pw2)
 891         {
 892                 ad->ed_pw2->group_style = SETTING_GROUP_STYLE_BOTTOM;
 893         }
 894
 895         ad->ed_pw3 = NULL;
 896         return 0;
 897 }
 898
 899 int setting_password_sim_clear_2line_entry(void *data)
 900 {
 901         SETTING_TRACE_BEGIN;
 902         /* error check */
 903         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 904                  "[Setting > Password] Data parameter is NULL");
 905
 906         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 907
 908         retv_if(NULL == ad->ed_pw1, -1);
 909         ad->ed_pw1->sub_desc = NULL;
 910         ad->ed_pw1->isFocusFlag = FALSE;
 911         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
 912         elm_object_part_text_set(ad->ed_pw1->eo_check, "elm.guide", _("Enter PIN"));
 913
 914         retv_if(NULL == ad->ed_pw2, -1);
 915         ad->ed_pw2->sub_desc = NULL;
 916         ad->ed_pw2->isFocusFlag = FALSE;
 917         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
 918         elm_object_part_text_set(ad->ed_pw1->eo_check, "elm.guide", _("Enter PIN"));
 919         return 0;
 920 }
 921
 922 int setting_password_sim_draw_3line_entry(void *data, void *cb)
 923 {
 924         /* error check */
 925         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
 926                  "[Setting > Password] Data parameter is NULL");
 927
 928         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 929
 930         switch (ad->view_type) {
 931         case SETTING_PW_TYPE_PIN_BLOCKED:
 932                 ad->ed_pw1 =
 933                     setting_create_Gendial_field_editfield(ad->scroller,
 934                                                        &(itc_editfield),
 935                                                        NULL, ad,
 936                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 937                                                        "IDS_ST_BODY_PUK1_CODE",
 938                                                        NULL,
 939                                                        setting_password_sim_entry_changed_cb,
 940                                                        __entry_focused_cb,
 941                                                        __entry_unfocused_cb,
 942                                                        __entry_activated_cb,
 943                                                        NULL,
 944                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 945                                                        TRUE, TRUE,
 946                                                        SETTING_PW_UG_PUK_MAX_LENGTH,
 947                                                        0, "0123456789", NULL);
 948
 949                 ad->ed_pw2 =
 950                     setting_create_Gendial_field_editfield(ad->scroller,
 951                                                        &(itc_editfield),
 952                                                        NULL, ad,
 953                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 954                                                        "IDS_ST_BODY_NEW_PIN1",
 955                                                        NULL,
 956                                                        setting_password_sim_entry_changed_cb,
 957                                                        __entry_focused_cb,
 958                                                        __entry_unfocused_cb,
 959                                                        __entry_activated_cb,
 960                                                        NULL,
 961                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 962                                                        TRUE, FALSE,
 963                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 964                                                        0, "0123456789", NULL);
 965
 966                 ad->ed_pw3 =
 967                     setting_create_Gendial_field_editfield(ad->scroller,
 968                                                        &(itc_editfield),
 969                                                        NULL, ad,
 970                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 971                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN1",
 972                                                        NULL,
 973                                                        setting_password_sim_entry_changed_cb,
 974                                                        __entry_focused_cb,
 975                                                        __entry_unfocused_cb,
 976                                                        NULL,
 977                                                        NULL,
 978                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 979                                                        TRUE, FALSE,
 980                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 981                                                        0, "0123456789", NULL);
 982                 break;
 983         case SETTING_PW_TYPE_PIN2_BLOCKED:
 984                 ad->ed_pw1 =
 985                     setting_create_Gendial_field_editfield(ad->scroller,
 986                                                        &(itc_editfield),
 987                                                        NULL, ad,
 988                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
 989                                                        "IDS_ST_BODY_PUK2", NULL,
 990                                                        setting_password_sim_entry_changed_cb,
 991                                                        __entry_focused_cb,
 992                                                        __entry_unfocused_cb,
 993                                                        __entry_activated_cb,
 994                                                        NULL,
 995                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
 996                                                        TRUE, TRUE,
 997                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
 998                                                        0, "0123456789", NULL);
 999
1000                 ad->ed_pw2 =
1001                     setting_create_Gendial_field_editfield(ad->scroller,
1002                                                        &(itc_editfield),
1003                                                        NULL, ad,
1004                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
1005                                                        "IDS_ST_BODY_NEW_PIN2",
1006                                                        NULL,
1007                                                        setting_password_sim_entry_changed_cb,
1008                                                        __entry_focused_cb,
1009                                                        __entry_unfocused_cb,
1010                                                        __entry_activated_cb,
1011                                                        NULL,
1012                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1013                                                        TRUE, FALSE,
1014                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1015                                                        0, "0123456789", NULL);
1016
1017                 ad->ed_pw3 =
1018                     setting_create_Gendial_field_editfield(ad->scroller,
1019                                                        &(itc_editfield),
1020                                                        NULL, ad,
1021                                                        SWALLOW_Type_LAYOUT_EDITFIELD,
1022                                                        "IDS_ST_BODY_CONFIRM_NEW_PIN2",
1023                                                        NULL,
1024                                                        setting_password_sim_entry_changed_cb,
1025                                                        __entry_focused_cb,
1026                                                        __entry_unfocused_cb,
1027                                                        NULL,
1028                                                        NULL,
1029                                                        ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,
1030                                                        TRUE, FALSE,
1031                                                        SETTING_PW_UG_PIN_MAX_LENGTH,
1032                                                        0, "0123456789", NULL);
1033                 break;
1034
1035         default:
1036                 break;
1037         }
1038         return 0;
1039 }
1040
1041 int setting_password_sim_clear_3line_entry(void *data)
1042 {
1043         /* error check */
1044         retvm_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER,
1045                  "[Setting > Password] Data parameter is NULL");
1046
1047         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1048         //Evas_Object *layout = NULL;
1049
1050         retv_if(NULL == ad->ed_pw1, -1);
1051         ad->ed_pw1->sub_desc = NULL;
1052         ad->ed_pw1->isFocusFlag = FALSE;
1053         elm_entry_entry_set(ad->ed_pw1->eo_check, "");
1054         elm_object_part_text_set(ad->ed_pw1->eo_check, "elm.guide", _("Enter PUK"));
1055
1056         retv_if(NULL == ad->ed_pw2, -1);
1057         ad->ed_pw2->sub_desc = NULL;
1058         ad->ed_pw2->isFocusFlag = FALSE;
1059         elm_entry_entry_set(ad->ed_pw2->eo_check, "");
1060         elm_object_part_text_set(ad->ed_pw2->eo_check, "elm.guide", _("Enter PIN"));
1061
1062         retv_if(NULL == ad->ed_pw3, -1);
1063         ad->ed_pw3->sub_desc = NULL;
1064         ad->ed_pw3->isFocusFlag = FALSE;
1065         elm_entry_entry_set(ad->ed_pw3->eo_check, "");
1066         elm_object_part_text_set(ad->ed_pw3->eo_check, "elm.guide", _("Enter PIN"));
1067
1068         return 0;
1069 }
1070
1071 int setting_password_sim_check_1line_entry(void *data)
1072 {
1073         /* error check */
1074         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1075
1076         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1077
1078         const char *entry_str = ad->ed_pw1->sub_desc;
1079         ad->focus_data = ad->ed_pw1;
1080
1081         /*  Length Check */
1082         int entry_str_len = safeStrLen(entry_str);
1083         switch (ad->view_type) {
1084         case SETTING_PW_TYPE_PIN_LOCK_ON:
1085         case SETTING_PW_TYPE_PIN_LOCK_OFF:
1086         case SETTING_PW_TYPE_CHANGE_PIN:
1087         case SETTING_PW_TYPE_CHANGE_PIN2:
1088                 {
1089                         if (entry_str_len < SETTING_PW_UG_PIN_MIN_LENGTH
1090                             || entry_str_len > SETTING_PW_UG_PIN_MAX_LENGTH) {
1091                                 setting_password_sim_warning_entry_added_byte_popup
1092                                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
1093                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1094                         }
1095                 }
1096                 break;
1097         case SETTING_PW_TYPE_SIM_LOCK_OFF:
1098                 {
1099                         if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
1100                             || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH) {
1101                                 setting_password_sim_warning_entry_added_byte_popup
1102                                         (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
1103                                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1104                         }
1105                 }
1106         default:
1107                 break;
1108         }
1109         return SETTING_RETURN_SUCCESS;
1110 }
1111
1112 int setting_password_sim_check_2line_entry(void *data)
1113 {
1114         /* error check */
1115         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1116
1117         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1118         if(ad->ed_pw1 == NULL || ad->ed_pw2 == NULL)
1119                 return SETTING_GENERAL_ERR_NULL_DATA_PARAMETER;
1120
1121         const char *entry_str1 = ad->ed_pw1->sub_desc;
1122         const char *entry_str2 = ad->ed_pw2->sub_desc;
1123         ad->focus_data = ad->ed_pw1;
1124
1125         /*  Match Check */
1126         if (0 != safeStrCmp(entry_str1, entry_str2)) {
1127                 setting_password_sim_clear_2line_entry(ad);
1128                 if(ad->view_type == SETTING_PW_TYPE_PIN_BLOCKED
1129                         || ad->view_type == SETTING_PW_TYPE_CHANGE_PIN
1130                         || ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
1131                 {
1132                         setting_password_ug_display_desc(ad, _("IDS_IDLE_BODY_NEW_PIN_AND_CONFIRM_PIN_DO_NOT_MATCH"), FALSE);
1133                 }
1134                 else if(ad->view_type == SETTING_PW_TYPE_CHANGE_PIN2)
1135                 {
1136                         setting_password_ug_display_desc(ad, _("IDS_ST_BODY_NEW_PIN2_AND_CONFIRM_PIN2_DO_NOT_MATCH"), FALSE);
1137                 }
1138
1139                 return SETTING_ENTRY_NOT_MATCH_NEW_CONF_PW;
1140         }
1141
1142 #if SUPPORT_SIMLOCK
1143         /*  Length Check */
1144         int entry_str_len = safeStrLen(entry_str1);
1145         if(ad->view_type == SETTING_PW_TYPE_SIM_LOCK_ON)
1146         {
1147                 if (entry_str_len < SETTING_PW_UG_SIM_MIN_LENGTH
1148                            || entry_str_len > SETTING_PW_UG_SIM_MAX_LENGTH)
1149                 {
1150                         setting_password_sim_warning_entry_added_byte_popup
1151                                 (ad, SETTING_PW_UG_SIM_MIN_LENGTH, SETTING_PW_UG_SIM_MAX_LENGTH);
1152                         return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1153                 }
1154         }
1155 #endif
1156
1157         return SETTING_RETURN_SUCCESS;
1158 }
1159
1160 void setting_password_sim_warning_entry_added_byte_popup(SettingPasswordUG *ad,
1161                                                      int min, int max)
1162 {
1163         char str[MAX_SPECIALIZITION_LEN + 1] = { 0 };
1164
1165         safeCopyStr(str, _("IDS_COM_BODY_TYPE_A_PIN_THAT_IS_4_TO_8_NUMBERS"), MAX_SPECIALIZITION_LEN);
1166         setting_password_ug_display_desc(ad, str, FALSE);
1167 }
1168
1169 int setting_password_sim_check_3line_entry(void *data)
1170 {
1171         /* error check */
1172         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1173
1174         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1175
1176         const char *entry_str1 = ad->ed_pw1->sub_desc;
1177         const char *entry_str2 = ad->ed_pw2->sub_desc;
1178         const char *entry_str3 = ad->ed_pw3->sub_desc;
1179         ad->focus_data = ad->ed_pw1;
1180
1181         /*  Length Check */
1182         int entry_str1_len = safeStrLen(entry_str1);
1183         int entry_str2_len = safeStrLen(entry_str2);
1184         int entry_str3_len = safeStrLen(entry_str3);
1185
1186         /* PUK code always should be 8 chars. */
1187         if (entry_str1_len != SETTING_PW_UG_PUK_MAX_LENGTH)
1188         {
1189                 setting_password_sim_warning_entry_added_byte_popup
1190                         (ad, SETTING_PW_UG_PUK_MAX_LENGTH, SETTING_PW_UG_PUK_MAX_LENGTH);
1191                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1192         }
1193         if (entry_str2_len < SETTING_PW_UG_PIN_MIN_LENGTH
1194                 || entry_str2_len > SETTING_PW_UG_PIN_MAX_LENGTH)
1195         {
1196                 ad->focus_data = ad->ed_pw2;
1197                 setting_password_sim_warning_entry_added_byte_popup
1198                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
1199                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1200         }
1201         if (entry_str3_len < SETTING_PW_UG_PIN_MIN_LENGTH
1202                 || entry_str3_len > SETTING_PW_UG_PIN_MAX_LENGTH)
1203         {
1204                 ad->focus_data = ad->ed_pw3;
1205                 setting_password_sim_warning_entry_added_byte_popup
1206                         (ad, SETTING_PW_UG_PIN_MIN_LENGTH, SETTING_PW_UG_PIN_MAX_LENGTH);
1207                 return SETTING_ENTRY_REQUIRED_CORRECT_DIGIT_PW;
1208         }
1209
1210         return SETTING_RETURN_SUCCESS;
1211 }
1212
1213 static void setting_password_sim_done(void *data)
1214 {
1215         SETTING_TRACE_BEGIN;
1216         ret_if(data == NULL);
1217         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1218
1219         app_control_h svc;
1220         if (app_control_create(&svc))
1221         {
1222                 SETTING_TRACE_ERROR("app_control_create() failed");
1223                 return;
1224         }
1225
1226         SETTING_TRACE("ad->view_type:%d", ad->view_type);
1227         int ret = 0;
1228
1229         switch (ad->view_type) {
1230                 case SETTING_PW_TYPE_PIN_LOCK_ON:
1231                         {
1232                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_ON");
1233
1234                                 ret = setting_password_sim_check_1line_entry(ad);
1235
1236                                 if (ret == SETTING_RETURN_SUCCESS) {
1237                                         TelSimFacilityPw_t sim_sec_data = { 0, };
1238                                         int tapi_ret = TAPI_API_SUCCESS;
1239                                         const char *entry_str;
1240
1241                                         entry_str = ad->ed_pw1->sub_desc;
1242                                         if (isEmptyStr(entry_str)) {
1243                                                 ad->focus_data = ad->ed_pw1;
1244                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
1245                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1246                                                 app_control_destroy(svc);
1247                                                 return;
1248                                         }
1249
1250                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_SC;//TAPI_SIM_PTYPE_PIN1
1251                                         sim_sec_data.pw = (unsigned char *)entry_str;
1252                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1253
1254                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
1255                                         setting_password_sim_clear_1line_entry(ad);
1256
1257                                         if (TAPI_API_SUCCESS != tapi_ret) {
1258                                                 ad->focus_data = ad->ed_pw1;
1259                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_facility err=%d ***%s",
1260                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1261                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1262                                         } else {
1263                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status                                           */
1264                                         }
1265                                 } else {
1266                                         setting_password_sim_clear_1line_entry(ad);
1267                                 }
1268                         }
1269                         app_control_destroy(svc);
1270                         return;
1271                 case SETTING_PW_TYPE_PIN_LOCK_OFF:
1272                         {
1273                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_LOCK_OFF");
1274
1275                                 ret = setting_password_sim_check_1line_entry(ad);
1276
1277                                 if (ret == SETTING_RETURN_SUCCESS) {
1278                                         TelSimFacilityPw_t sim_sec_data = { 0, };
1279                                         int tapi_ret = TAPI_API_SUCCESS;
1280                                         const char *entry_str;
1281
1282                                         entry_str = ad->ed_pw1->sub_desc;
1283                                         if (isEmptyStr(entry_str)) {
1284                                                 ad->focus_data = ad->ed_pw1;
1285                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
1286                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1287                                                 app_control_destroy(svc);
1288                                                 return;
1289                                         }
1290
1291                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_SC;//TAPI_SIM_PTYPE_PIN1
1292                                         sim_sec_data.pw = (unsigned char *)entry_str;
1293                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1294
1295                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
1296                                         setting_password_sim_clear_1line_entry(ad);
1297
1298                                         if (TAPI_API_SUCCESS != tapi_ret) {
1299                                                 ad->focus_data = ad->ed_pw1;
1300                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_facility err=%d ***%s",
1301                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1302                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1303                                         } else {
1304                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status                                           */
1305                                         }
1306                                 } else {
1307                                         setting_password_sim_clear_1line_entry(ad);
1308                                 }
1309                         }
1310                         app_control_destroy(svc);
1311                         return;
1312                 case SETTING_PW_TYPE_PIN_BLOCKED:
1313                         {
1314                                 /*  PIN1 Status is "Blocked": User should input puk code and new pin1 code. */
1315                                 /*  If puk code is correct and success to modify pin1 code, display pin1 code change popup */
1316                                 /*  But, if this menu is "Pin Lock", pinlock status will not be changed. */
1317                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN_BLOCKED");
1318                                 if(ad->cur_pwd == NULL)
1319                                 {
1320                                         ret = setting_password_sim_check_1line_entry(ad);
1321                                         if(ret == SETTING_RETURN_SUCCESS)
1322                                         {
1323                                                 ad->cur_pwd = (char *)strdup(ad->ed_pw1->sub_desc);
1324                                                 elm_genlist_clear(ad->scroller);
1325                                                 ADD_GL_SEPARATOR(ad->scroller)
1326                                                 setting_password_sim_draw_2line_entry(ad, NULL);
1327                                         }
1328                                         else
1329                                         {
1330                                                 setting_password_sim_clear_1line_entry(ad);
1331                                         }
1332                                 }
1333                                 else
1334                                 {
1335                                         ret = setting_password_sim_check_2line_entry(ad);
1336
1337                                         if (ret == SETTING_RETURN_SUCCESS) {
1338                                                 TelSimSecPw_t puk1_data = { 0, };
1339                                                 TelSimSecPw_t pin1_data = { 0, };
1340                                                 int tapi_ret = TAPI_API_SUCCESS;
1341                                                 const char *puk;
1342                                                 const char *new_pin1;
1343
1344                                                 puk = ad->cur_pwd;
1345                                                 new_pin1 = ad->ed_pw1->sub_desc;
1346
1347                                                 puk1_data.type = TAPI_SIM_PTYPE_PUK1;
1348                                                 puk1_data.pw = (unsigned char *)puk;
1349                                                 puk1_data.pw_len = safeStrLen(puk);
1350
1351                                                 pin1_data.type = TAPI_SIM_PTYPE_PIN1;
1352                                                 pin1_data.pw = (unsigned char *)new_pin1;
1353                                                 pin1_data.pw_len = safeStrLen(new_pin1);
1354
1355                                                 tapi_ret = tel_verify_sim_puks(ad->handle, &puk1_data, &pin1_data, setting_sim_verify_puks_cb, ad);
1356                                                 FREE(ad->cur_pwd);
1357                                                 ad->cur_pwd = NULL;
1358
1359                                                 setting_password_sim_clear_2line_entry(ad);
1360
1361                                                 if (TAPI_API_SUCCESS != tapi_ret) {
1362                                                         ad->focus_data = ad->ed_pw1;
1363                                                         SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
1364                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1365                                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1366                                                 } else {
1367                                                         /*  Success. Send Message to Caller for Modify Pin Lock slider status */
1368
1369                                                 }
1370                                         } else {
1371                                                 setting_password_sim_clear_2line_entry(ad);
1372                                         }
1373                                 }
1374                         }
1375                         app_control_destroy(svc);
1376                         return;
1377                 case SETTING_PW_TYPE_PIN2_BLOCKED:
1378                         {
1379                                 SETTING_TRACE("case SETTING_PW_TYPE_PIN2_BLOCKED");
1380                                 ret = setting_password_sim_check_3line_entry(ad);
1381
1382                                 if (ret == SETTING_RETURN_SUCCESS) {
1383                                         TelSimSecPw_t puk2_data = { 0, };
1384                                         TelSimSecPw_t pin2_data = { 0, };
1385                                         int tapi_ret = TAPI_API_SUCCESS;
1386                                         const char *puk;
1387                                         const char *new_pin2;
1388
1389                                         puk = ad->ed_pw1->sub_desc;
1390                                         new_pin2 = ad->ed_pw2->sub_desc;
1391                                         if (isEmptyStr(puk)) {
1392                                                 ad->focus_data = ad->ed_pw1;
1393                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1394                                                 app_control_destroy(svc);
1395                                                 return;
1396                                         }
1397
1398                                         if (isEmptyStr(new_pin2)) {
1399                                                 ad->focus_data = ad->ed_pw2;
1400                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1401                                                 app_control_destroy(svc);
1402                                                 return;
1403                                         }
1404
1405                                         puk2_data.type = TAPI_SIM_PTYPE_PUK2;
1406                                         puk2_data.pw = (unsigned char *)puk;
1407                                         puk2_data.pw_len = safeStrLen(puk);
1408
1409                                         pin2_data.type = TAPI_SIM_PTYPE_PIN2;
1410                                         pin2_data.pw = (unsigned char *)new_pin2;
1411                                         pin2_data.pw_len = safeStrLen(new_pin2);
1412
1413                                         tapi_ret = tel_verify_sim_puks(ad->handle, &puk2_data, &pin2_data, setting_sim_verify_puks_cb, ad);
1414                                         setting_password_sim_clear_3line_entry(ad);
1415
1416                                         if (TAPI_API_SUCCESS != tapi_ret) {
1417                                                 ad->focus_data = ad->ed_pw1;
1418                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_verify_sim_puks err=%d ***%s",
1419                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1420                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1421                                         } else {
1422                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
1423
1424                                         }
1425                                 } else {
1426                                         setting_password_sim_clear_3line_entry(ad);
1427                                 }
1428                         }
1429                         app_control_destroy(svc);
1430                         return;
1431                 case SETTING_PW_TYPE_CHANGE_PIN:
1432                         {
1433                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN");
1434                                 if(ad->cur_pwd)
1435                                 {
1436                                         SETTING_TRACE("step #2. new pins");
1437                                         ret = setting_password_sim_check_2line_entry(ad);
1438                                         if (ret == SETTING_RETURN_SUCCESS) {
1439                                                 const char *old_pw;
1440                                                 const char *new_pw;
1441                                                 TelSimSecPw_t sim_old_sec_data = { 0, };
1442                                                 TelSimSecPw_t sim_new_sec_data = { 0, };
1443                                                 int tapi_ret = TAPI_API_SUCCESS;
1444
1445                                                 old_pw = ad->cur_pwd;
1446                                                 new_pw = ad->ed_pw1->sub_desc;
1447                                                 sim_old_sec_data.type = TAPI_SIM_PTYPE_PIN1;
1448                                                 sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN1;
1449                                                 sim_old_sec_data.pw = (unsigned char *)old_pw;
1450                                                 sim_old_sec_data.pw_len = safeStrLen(old_pw);
1451                                                 sim_new_sec_data.pw = (unsigned char *)new_pw;
1452                                                 sim_new_sec_data.pw_len = safeStrLen(new_pw);
1453
1454                                                 tapi_ret = tel_change_sim_pins(ad->handle, &sim_old_sec_data, &sim_new_sec_data, setting_sim_change_pins_cb, ad);
1455                                                 setting_password_sim_clear_2line_entry(ad);
1456
1457                                                 if (TAPI_API_SUCCESS != tapi_ret) {
1458                                                         ad->focus_data = ad->ed_pw1;
1459                                                         SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
1460                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1461                                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1462                                                 }
1463                                         } else {
1464                                                 setting_password_sim_clear_2line_entry(ad);
1465                                         }
1466                                 }
1467                                 else
1468                                 {
1469                                         SETTING_TRACE("step #1. current pin");
1470                                         // keep cur_pwd
1471                                         ret = setting_password_sim_check_1line_entry(ad);
1472                                         if(ret == SETTING_RETURN_SUCCESS)
1473                                         {
1474                                                 ad->cur_pwd = (char *)strdup(ad->ed_pw1->sub_desc);
1475                                                 //ad->update_change_pin1_flag = TRUE;
1476                                                 //setting_view_update(&setting_view_password_main, ad);
1477
1478                                                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->ed_pw1->eo_check);
1479                                                 if(imf_context)
1480                                                 {
1481                                                         SETTING_TRACE_DEBUG("imf_context (0x%.8x) : clear event callbacks", imf_context);
1482                                                         ecore_imf_context_input_panel_event_callback_clear(imf_context);
1483                                                 }
1484
1485                                                 elm_genlist_clear(ad->scroller);
1486                                                 ADD_GL_SEPARATOR(ad->scroller)
1487                                                 setting_password_sim_draw_2line_entry(ad, NULL);
1488                                                 ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
1489                                         }
1490                                         else
1491                                         {
1492                                                 setting_password_sim_clear_1line_entry(ad);
1493                                         }
1494                                 }
1495                         }
1496                         app_control_destroy(svc);
1497                         return;
1498                 case SETTING_PW_TYPE_CHANGE_PIN2:
1499                         {
1500                                 SETTING_TRACE("case SETTING_PW_TYPE_CHANGE_PIN2");
1501                                 if(ad->cur_pwd)
1502                                 {
1503                                         SETTING_TRACE("step #2. new pin2s");
1504                                         ret = setting_password_sim_check_2line_entry(ad);
1505                                         if (ret == SETTING_RETURN_SUCCESS) {
1506                                                 const char *old_pw;
1507                                                 const char *new_pw;
1508                                                 TelSimSecPw_t sim_old_sec_data = { 0, };
1509                                                 TelSimSecPw_t sim_new_sec_data = { 0, };
1510                                                 int tapi_ret = TAPI_API_SUCCESS;
1511
1512                                                 old_pw = ad->cur_pwd;
1513                                                 new_pw = ad->ed_pw1->sub_desc;
1514
1515                                                 sim_old_sec_data.type = TAPI_SIM_PTYPE_PIN2;
1516                                                 sim_new_sec_data.type = TAPI_SIM_PTYPE_PIN2;
1517                                                 sim_old_sec_data.pw = (unsigned char *)old_pw;
1518                                                 sim_old_sec_data.pw_len = safeStrLen(old_pw);
1519                                                 sim_new_sec_data.pw = (unsigned char *)new_pw;
1520                                                 sim_new_sec_data.pw_len = safeStrLen(new_pw);
1521
1522                                                 tapi_ret = tel_change_sim_pins(ad->handle, &sim_old_sec_data, &sim_new_sec_data, setting_sim_change_pins_cb, ad);
1523                                                 setting_password_sim_clear_2line_entry(ad);
1524
1525                                                 if (TAPI_API_SUCCESS != tapi_ret) {
1526                                                         ad->focus_data = ad->ed_pw1;
1527                                                         SETTING_TRACE_DEBUG("%s*** [ERR] TelTapiSimChangePIN err=%d ***%s",
1528                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1529                                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1530                                                 }
1531                                         } else {
1532                                                 setting_password_sim_clear_2line_entry(ad);
1533                                         }
1534                                 }
1535                                 else
1536                                 {
1537                                         SETTING_TRACE("step #1. current pin2");
1538                                         // keep cur_pwd
1539                                         ret = setting_password_sim_check_1line_entry(ad);
1540                                         if(ret == SETTING_RETURN_SUCCESS)
1541                                         {
1542                                                 ad->cur_pwd = (char *)strdup(ad->ed_pw1->sub_desc);
1543
1544                                                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(ad->ed_pw1->eo_check);
1545                                                 if(imf_context)
1546                                                 {
1547                                                         SETTING_TRACE_DEBUG("imf_context (0x%.8x) : clear event callbacks", imf_context);
1548                                                         ecore_imf_context_input_panel_event_callback_clear(imf_context);
1549                                                 }
1550
1551                                                 elm_genlist_clear(ad->scroller);
1552                                                 ADD_GL_SEPARATOR(ad->scroller)
1553                                                 setting_password_sim_draw_2line_entry(ad, NULL);
1554                                                 ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
1555                                         }
1556                                         else
1557                                         {
1558                                                 setting_password_sim_clear_1line_entry(ad);
1559                                         }
1560                                 }
1561                         }
1562                         app_control_destroy(svc);
1563                         return;
1564 #if SUPPORT_SIMLOCK
1565                 case SETTING_PW_TYPE_SIM_LOCK_ON:
1566                         {
1567                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_ON");
1568
1569                                 ret = setting_password_sim_check_2line_entry(ad);
1570
1571                                 if (ret == SETTING_RETURN_SUCCESS) {
1572                                         TelSimFacilityPw_t sim_sec_data = { 0, };
1573                                         int tapi_ret = TAPI_API_SUCCESS;
1574                                         const char *entry_str;
1575                                         entry_str = ad->ed_pw1->sub_desc;
1576                                         if (isEmptyStr(entry_str)) {
1577                                                 ad->focus_data = ad->ed_pw1;
1578                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1579                                                 app_control_destroy(svc);
1580                                                 return;
1581                                         }
1582
1583                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_PS;//TAPI_SIM_PTYPE_SIM
1584                                         sim_sec_data.pw = (unsigned char *)entry_str;
1585                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1586
1587                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
1588                                         setting_password_sim_clear_2line_entry(ad);
1589
1590                                         SETTING_TRACE_SECURE_DEBUG("SIM Lock password : %s\n", (char *)(sim_sec_data.pw));
1591                                         if (TAPI_API_SUCCESS != tapi_ret) {
1592                                                 ad->focus_data = ad->ed_pw1;
1593                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_enable_sim_facility err=%d ***%s",
1594                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1595                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1596                                         } else {
1597                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
1598
1599                                         }
1600                                 } else {
1601                                         setting_password_sim_clear_2line_entry(ad);
1602                                 }
1603                         }
1604                         app_control_destroy(svc);
1605                         return;
1606                 case SETTING_PW_TYPE_SIM_LOCK_OFF:
1607                         {
1608                                 SETTING_TRACE("case SETTING_PW_TYPE_SIM_LOCK_OFF");
1609
1610                                 ret = setting_password_sim_check_1line_entry(ad);
1611                                 if (ret == SETTING_RETURN_SUCCESS) {
1612                                         TelSimFacilityPw_t sim_sec_data = { 0, };
1613                                         int tapi_ret = TAPI_API_SUCCESS;
1614                                         const char *entry_str;
1615
1616                                         entry_str = ad->ed_pw1->sub_desc;
1617                                         if (isEmptyStr(entry_str)) {
1618                                                 ad->focus_data = ad->ed_pw1;
1619                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1620                                                 app_control_destroy(svc);
1621                                                 return;
1622                                         }
1623
1624                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_PS;//TAPI_SIM_PTYPE_SIM
1625                                         sim_sec_data.pw = (unsigned char *)entry_str;
1626                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1627
1628                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
1629                                         setting_password_sim_clear_1line_entry(ad);
1630
1631                                         if (TAPI_API_SUCCESS != tapi_ret) {
1632                                                 ad->focus_data = ad->ed_pw1;
1633                                                 SETTING_TRACE_DEBUG("%s*** [ERR] tel_disable_sim_facility err=%d ***%s",
1634                                                                                 SETTING_FONT_RED, tapi_ret, SETTING_FONT_BLACK);
1635                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1636                                         } else {
1637                                                 /*  Success. Send Message to Caller for Modify Pin Lock slider status */
1638
1639                                         }
1640                                 } else {
1641                                         setting_password_sim_clear_1line_entry(ad);
1642                                 }
1643                         }
1644                         app_control_destroy(svc);
1645                         return;
1646 #endif
1647 #if SUPPORT_FDN
1648                 case SETTING_PW_TYPE_FDN_MODE_ON:
1649                         {
1650                                 SETTING_TRACE("case SETTING_PW_TYPE_FDN_MODE_ON");
1651                                 ret = setting_password_sim_check_1line_entry(ad);
1652
1653                                 if(ret == SETTING_RETURN_SUCCESS)
1654                                 {
1655                                         const char *entry_str;
1656                                         int tapi_ret = TAPI_API_INVALID_INPUT;
1657
1658                                         TelSimFacilityPw_t sim_sec_data = {0,};
1659                                         int ReqId;
1660
1661                                         entry_str = ad->ed_pw1->sub_desc;
1662                                         if(isEmptyStr(entry_str))
1663                                         {
1664                                                 ad->focus_data = ad->ed_pw1;
1665                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
1666                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1667                                                 app_control_destroy(svc);
1668                                                 return;
1669                                         }
1670                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_FD;//TAPI_SIM_PTYPE_PIN2;
1671                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1672                                         sim_sec_data.pw = (unsigned char*)entry_str;
1673
1674                                         tapi_ret = tel_enable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_enable_cb, ad);
1675                                         setting_password_sim_clear_1line_entry(ad);
1676
1677                                         if(tapi_ret != TAPI_API_SUCCESS)
1678                                         {
1679                                                 ad->focus_data = ad->ed_pw1;
1680                                                 SETTING_TRACE_ERROR("[ERR] Failed to enable FDN. Tapi return %d", tapi_ret);
1681                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1682                                                 app_control_destroy(svc);
1683                                                 return;
1684                                         }
1685
1686                                         app_control_add_extra_data(svc, "result", ad->view_type_string);
1687                                         ug_send_result(ad->ug, svc);
1688                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1689                                         app_control_destroy(svc);
1690                                         //ug_destroy_me(ad->ug);
1691                                 }
1692                                 else
1693                                 {
1694                                         /* check failed */
1695                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), TRUE);
1696                                 }
1697                         }
1698                         break;
1699                 case SETTING_PW_TYPE_FDN_MODE_OFF:
1700                         {
1701                                 SETTING_TRACE("case SETTING_PW_TYPE_FDN_MODE_OFF");
1702                                 ret = setting_password_sim_check_1line_entry(ad);
1703
1704                                 if(ret == SETTING_RETURN_SUCCESS)
1705                                 {
1706                                         const char *entry_str;
1707                                         int tapi_ret = TAPI_API_INVALID_INPUT;
1708
1709                                         TelSimFacilityPw_t sim_sec_data = {0,};
1710
1711                                         entry_str = ad->ed_pw1->sub_desc;
1712                                         if(isEmptyStr(entry_str))
1713                                         {
1714                                                 ad->focus_data = ad->ed_pw1;
1715                                                 SETTING_TRACE_ERROR("[ERR] elm_entry_entry_get(ad->ed_pw1) return NULL!");
1716                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1717                                                 app_control_destroy(svc);
1718                                                 return;
1719                                         }
1720                                         sim_sec_data.lock_type = TAPI_SIM_LOCK_FD;//TAPI_SIM_PTYPE_PIN2
1721                                         sim_sec_data.pw_len = safeStrLen(entry_str);
1722                                         sim_sec_data.pw = (unsigned char*)entry_str;
1723
1724                                         tapi_ret = tel_disable_sim_facility(ad->handle, &sim_sec_data, setting_sim_facility_disable_cb, ad);
1725                                         setting_password_sim_clear_1line_entry(ad);
1726
1727                                         if(tapi_ret != TAPI_API_SUCCESS)
1728                                         {
1729                                                 ad->focus_data = ad->ed_pw1;
1730                                                 SETTING_TRACE_ERROR("[ERR] Failed to disable FDN. Tapi return %d", tapi_ret);
1731                                                 setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), FALSE);
1732                                                 app_control_destroy(svc);
1733                                                 return;
1734                                         }
1735
1736                                         app_control_add_extra_data(svc, "result", ad->view_type_string);
1737                                         ug_send_result(ad->ug, svc);
1738                                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1739
1740                                         app_control_destroy(svc);
1741                                         //ug_destroy_me(ad->ug);
1742                                 }
1743                                 else
1744                                 {
1745                                         /* check failed */
1746                                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_COM_POP_ERROR"), TRUE);
1747                                 }
1748                         }
1749                         break;
1750 #endif
1751                 default:
1752                         app_control_destroy(svc);
1753                         return;
1754         }
1755
1756         app_control_add_extra_data(svc, "result", ad->view_type_string);
1757         ug_send_result(ad->ug, svc);
1758         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1759
1760         app_control_destroy(svc);
1761         /* Send destroy request */
1762         ug_destroy_me(ad->ug);
1763 }
1764
1765 void setting_password_sim_click_softkey_done_cb(void *data, Evas_Object *obj,
1766                                             void *event_info)
1767 {
1768         SETTING_TRACE_BEGIN;
1769         /* error check */
1770         retm_if(data == NULL, "[Setting > Password] Data parameter is NULL");
1771
1772         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1773
1774         if(ad->ed_pw1 && ad->ed_pw1->eo_check)
1775         {
1776                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_FALSE);
1777         }
1778         if(ad->ed_pw2 && ad->ed_pw2->eo_check)
1779         {
1780                 elm_object_focus_set(ad->ed_pw2->eo_check, EINA_FALSE);
1781         }
1782         if(ad->ed_pw3 && ad->ed_pw3->eo_check)
1783         {
1784                 elm_object_focus_set(ad->ed_pw3->eo_check, EINA_FALSE);
1785         }
1786
1787         if(ad->err_desc && ad->err_desc->item)
1788         {
1789                 elm_object_item_del(ad->err_desc->item);
1790                 ad->err_desc = NULL;
1791         }
1792
1793         setting_password_sim_done(ad);
1794 }
1795
1796 void setting_get_sim_lock_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
1797 {
1798         SETTING_TRACE_BEGIN;
1799         ret_if(data == NULL || user_data == NULL);
1800
1801         TelSimPinOperationResult_t sec_rt = result;
1802         TelSimLockInfo_t *lock = data;
1803
1804         SettingPasswordUG *ad = (SettingPasswordUG *)user_data;
1805
1806         SETTING_TRACE_SECURE_DEBUG("sec_ret[%d], lock_type[%d], lock_status[%d], retry_count[%d]", sec_rt, lock->lock_type, lock->lock_status, lock->retry_count);
1807
1808         char temp[256] ={0,};
1809         if(lock->retry_count > 1)
1810                 snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
1811         else if(lock->retry_count > 0)
1812                 snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
1813
1814         if(ad->err_desc && ad->err_desc->item)
1815         {
1816                 elm_object_item_del(ad->err_desc->item);
1817                 ad->err_desc = NULL;
1818         }
1819         ad->err_desc = setting_create_Gendial_field_helpitem_without_bottom_separator(
1820                                                                                                         ad->scroller,
1821                                                                                                         &(itc_multiline_text),
1822                                                                                                         SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1823                                                                                                         temp);
1824 }
1825
1826 void setting_get_pin_lock_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
1827 {
1828         SETTING_TRACE_BEGIN;
1829
1830         TelSimPinOperationResult_t sec_rt = result;
1831         TelSimLockInfo_t *lock = data;
1832
1833
1834         SettingPasswordUG *ad = (SettingPasswordUG *)user_data;
1835
1836         SETTING_TRACE_SECURE_DEBUG("sec_ret[%d], lock_type[%d], lock_status[%d], retry_count[%d]", sec_rt, lock->lock_type, lock->lock_status, lock->retry_count);
1837
1838         char temp[256] ={0,};
1839         if (ad->view_type == SETTING_PW_TYPE_CHANGE_PIN)
1840         {
1841                 char rtemp[SETTING_STR_SLP_LEN] ={0,};
1842                 if(ad->incorrect_pin1_flag)
1843                 {
1844                         if (lock->retry_count > 1) {
1845                                 snprintf(rtemp, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_BODY_INCORRECT_PIN_E"), _(ATTEMPTS_DESC));
1846                                 snprintf(temp, SETTING_STR_SLP_LEN, rtemp, lock->retry_count);
1847                         } else {
1848                                 snprintf(rtemp, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_BODY_INCORRECT_PIN_E"), _(ATTEMPT_DESC));
1849                                 snprintf(temp, SETTING_STR_SLP_LEN, rtemp, lock->retry_count);
1850                         }
1851                 }
1852                 else
1853                 {
1854                         if(lock->retry_count > 1)
1855                                 snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
1856                         else if(lock->retry_count > 0)
1857                                 snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
1858                 }
1859         }
1860         else if (ad->view_type == SETTING_PW_TYPE_CHANGE_PIN2)
1861         {
1862                 char rtemp[SETTING_STR_SLP_LEN] ={0,};
1863                 if(ad->incorrect_pin2_flag)
1864                 {
1865                         if (lock->retry_count > 1) {
1866                                 snprintf(rtemp, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PIN2"), _(ATTEMPTS_DESC));
1867                                 snprintf(temp, SETTING_STR_SLP_LEN, rtemp, lock->retry_count);
1868                         } else {
1869                                 snprintf(rtemp, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PIN2"), _(ATTEMPT_DESC));
1870                                 snprintf(temp, SETTING_STR_SLP_LEN, rtemp, lock->retry_count);
1871                         }
1872                 }
1873                 else
1874                 {
1875                         if(lock->retry_count > 1)
1876                                 snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
1877                         else if(lock->retry_count > 0)
1878                                 snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
1879                 }
1880         }
1881         else
1882         {
1883                 if(lock->retry_count > 1)
1884                         snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
1885                 else if(lock->retry_count > 0)
1886                         snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
1887         }
1888
1889         if(ad->err_desc && ad->err_desc->item)
1890         {
1891                 elm_object_item_del(ad->err_desc->item);
1892                 ad->err_desc = NULL;
1893         }
1894         ad->err_desc = setting_create_Gendial_field_helpitem_without_bottom_separator(
1895                                                                                                         ad->scroller,
1896                                                                                                         &(itc_multiline_text),
1897                                                                                                         SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1898                                                                                                         temp);
1899 }
1900
1901 void setting_sim_change_pins_cb(TapiHandle *handle, int result, void *data, void *user_data)
1902 {
1903         SETTING_TRACE_BEGIN;
1904         ret_if(!user_data || !data);
1905         TelSimPinOperationResult_t sec_rt = result;
1906         tapi_receive_info result_info = { 0, };
1907         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
1908         SETTING_TRACE_SECURE_DEBUG("sec_rt[%d]", sec_rt);
1909         SETTING_TRACE_SECURE_DEBUG("sim_event_data->type:%d", sim_event_data->type);
1910         SETTING_TRACE_SECURE_DEBUG("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
1911
1912         if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt) {
1913                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
1914                         result_info.stat = SIM_PIN1_CHANGE_SUCCESS;
1915                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
1916                         result_info.stat = SIM_PIN2_CHANGE_SUCCESS;
1917         } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
1918                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
1919                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
1920                         result_info.retry_cnt = sim_event_data->retry_count;
1921                 } else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type) {
1922                         result_info.stat = SIM_INCORRECT_PIN2_CODE;
1923                         result_info.retry_cnt = sim_event_data->retry_count;
1924                 }
1925         } else if (TAPI_SIM_PUK_REQUIRED == sec_rt) {
1926                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
1927                         result_info.stat = SIM_PIN1_BLOCKED;
1928                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
1929                         result_info.stat = SIM_PIN2_BLOCKED;
1930         } else {
1931                 SETTING_TRACE_DEBUG
1932                     ("%s*** [ERR] INCORRECTED ***%s",
1933                      SETTING_FONT_RED, SETTING_FONT_BLACK);
1934                 return;
1935         }
1936         setting_password_ug_display_result_popup(&result_info, user_data);
1937 }
1938
1939 void setting_sim_verify_puks_cb(TapiHandle *handle, int result, void *data, void *user_data)
1940 {
1941         SETTING_TRACE_BEGIN;
1942
1943         ret_if(!user_data || !data);
1944         SettingPasswordUG *ad = user_data;
1945         TelSimPinOperationResult_t sec_rt = result;
1946         tapi_receive_info result_info = { 0, };
1947         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
1948         ad->verify_puks_result = sim_event_data;
1949         SETTING_TRACE_SECURE_DEBUG("sec_rt[%d]", sec_rt);
1950         SETTING_TRACE_SECURE_DEBUG("sim_event_data->type:%d", sim_event_data->type);
1951         SETTING_TRACE_SECURE_DEBUG("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
1952
1953         if (TAPI_SIM_PTYPE_PUK1 == sim_event_data->type)
1954         {
1955                 //if (TAPI_SIM_PIN_REQUIRED == sec_rt){
1956                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
1957                         SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
1958                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN1_UNBLOCKED")+1);
1959
1960                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
1961                         snprintf(tmp_str, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_PUK1_VERIFIED"), _("IDS_ST_POP_PIN_UNBLOCKED"));
1962                         setting_password_ug_create_popup_notitle_nobtn(ad, tmp_str, TRUE);
1963                         return;
1964                 } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
1965                         result_info.stat = SIM_INCORRECT_PUK1_CODE;
1966                         result_info.retry_cnt = sim_event_data->retry_count;
1967                         ad->puk_verified_flag = TRUE;
1968                         setting_view_update(&setting_view_password_main, ad);
1969                 } else if (TAPI_SIM_PUK_INCORRECT_PASSWORD == sec_rt) {
1970                         if(sim_event_data->retry_count <= 0)
1971                         {
1972                                 result_info.stat = SIM_PUK1_BLOCKED;
1973                                 result_info.retry_cnt = 0;
1974                         }
1975                         else
1976                         {
1977                                 result_info.stat = SIM_INCORRECT_PUK1_CODE;
1978                                 result_info.retry_cnt = sim_event_data->retry_count;
1979                                 ad->puk_verified_flag = TRUE;
1980                                 setting_view_update(&setting_view_password_main, ad);
1981                         }
1982                 } else if (TAPI_SIM_PERM_BLOCKED == sec_rt) {
1983                         result_info.stat = SIM_PUK1_BLOCKED;
1984                         result_info.retry_cnt = 0;
1985                 } else {
1986                         result_info.stat = SIM_UNKNOWN_ERROR;
1987                 }
1988         }
1989
1990         else if (TAPI_SIM_PTYPE_PUK2 == sim_event_data->type)
1991         {
1992                 SETTING_TRACE_DEBUG("sec_rt : %d", sec_rt);
1993                 //if (TAPI_SIM_PUK_REQUIRED == sec_rt)
1994                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
1995                         SETTING_TRACE_DEBUG("SIM_PIN2_UNBLOCKED");
1996                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN2_UNBLOCKED")+1);
1997                         //char tmp_str[SETTING_STR_SLP_LEN] = {0,};
1998                         //snprintf(tmp_str, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_PUK2_VERIFIED"), _("IDS_ST_POP_PIN2_UNBLOCKED"));
1999                         setting_password_ug_create_popup_notitle_nobtn(ad, _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
2000                         return;
2001                 } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
2002                         SETTING_TRACE_DEBUG("stat : SIM_INCORRECT_PUK2_CODE");
2003                         result_info.stat = SIM_INCORRECT_PUK2_CODE;
2004                         result_info.retry_cnt = sim_event_data->retry_count;
2005                 } else if (TAPI_SIM_PUK_INCORRECT_PASSWORD == sec_rt) {
2006                         SETTING_TRACE_DEBUG("stat : SIM_INCORRECT_PUK2_CODE");
2007                         if(sim_event_data->retry_count <= 0)
2008                         {
2009                                 result_info.stat = SIM_PUK2_BLOCKED;
2010                                 result_info.retry_cnt = 0;
2011                         }
2012                         else
2013                         {
2014                                 result_info.stat = SIM_INCORRECT_PUK2_CODE;
2015                                 result_info.retry_cnt = sim_event_data->retry_count;
2016                         }
2017                 } else if (TAPI_SIM_PERM_BLOCKED == sec_rt) {
2018                         result_info.stat = SIM_PUK2_BLOCKED;
2019                         result_info.retry_cnt = 0;
2020                 } else {
2021                         result_info.stat = SIM_UNKNOWN_ERROR;
2022                 }
2023         }
2024         else
2025         {
2026                 result_info.stat = SIM_UNKNOWN_ERROR;
2027         }
2028         setting_password_ug_display_result_popup(&result_info, user_data);
2029 }
2030
2031 void setting_sim_facility_enable_cb(TapiHandle *handle, int result, void *data, void *user_data)
2032 {
2033         SETTING_TRACE_BEGIN;
2034         ret_if(!user_data);
2035
2036         SETTING_TRACE_SECURE_DEBUG("result[%d]", result);
2037         if(result == TAPI_API_SIM_LOCKED)       /* -503 error */
2038         {
2039                 setting_password_ug_create_popup_notitle_nobtn(user_data, _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
2040                 return;
2041         }
2042         ret_if(!data);
2043         tapi_receive_info result_info = { 0, };
2044         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
2045
2046         SETTING_TRACE_SECURE_DEBUG("sim_event_data->type:%d", sim_event_data->type);
2047         SETTING_TRACE_SECURE_DEBUG("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
2048
2049         /*  Sim Lock  */
2050         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
2051                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_SIM == sim_event_data->type");
2052                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == result)
2053                         result_info.stat = SIM_LOCK_ON_SUCCESS;
2054                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == result)
2055                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
2056                 else {
2057                         SETTING_TRACE_DEBUG("%s*** [ERR] INCORRECTED ***%s",
2058                              SETTING_FONT_RED,
2059                              SETTING_FONT_BLACK);
2060                         return;
2061                 }
2062         }
2063         /*  Pin Lock */
2064         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
2065                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_PIN1 == sim_event_data->type");
2066                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == result)
2067                         result_info.stat = SIM_PIN_LOCK_ON_SUCCESS;
2068                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == result) {
2069                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
2070                         result_info.retry_cnt = sim_event_data->retry_count;
2071                 } else if (TAPI_SIM_PUK_REQUIRED == result)
2072                         result_info.stat = SIM_PIN1_BLOCKED;
2073
2074                 /*  Pre CCF */
2075                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == result
2076                          || TAPI_SIM_CARD_ERROR == result) {
2077                         /*  popup */
2078                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
2079                 }
2080                 else {
2081                         SETTING_TRACE_DEBUG
2082                             ("%s*** [ERR] INCORRECTED ***%s",
2083                              SETTING_FONT_RED,
2084                              SETTING_FONT_BLACK);
2085                         return;
2086                 }
2087         }
2088         setting_password_ug_display_result_popup(&result_info, user_data);
2089 }
2090
2091 void setting_sim_facility_disable_cb(TapiHandle *handle, int result, void *data, void *user_data)
2092 {
2093         SETTING_TRACE_BEGIN;
2094         ret_if(!user_data);
2095
2096         SETTING_TRACE_SECURE_DEBUG("result[%d]", result);
2097         if(result == TAPI_API_SIM_LOCKED) /* -503 error */
2098         {
2099                 setting_password_ug_create_popup_notitle_nobtn(user_data, _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
2100                 return;
2101         }
2102         ret_if(!data);
2103         tapi_receive_info result_info = { 0, };
2104         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
2105
2106         SETTING_TRACE_SECURE_DEBUG("sim_event_data->type:%d", sim_event_data->type);
2107         SETTING_TRACE_SECURE_DEBUG("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
2108
2109         /*  Sim Lock  */
2110         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
2111                 SETTING_TRACE_DEBUG("SIM lOCK");
2112                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == result)
2113                         result_info.stat = SIM_LOCK_OFF_SUCCESS;
2114                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == result)
2115                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
2116                 else {
2117                         SETTING_TRACE_DEBUG
2118                             ("%s*** [ERR] INCORRECTED ***%s",
2119                              SETTING_FONT_RED,
2120                              SETTING_FONT_BLACK);
2121                         return;
2122                 }
2123         }
2124         /*  Pin Lock */
2125         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
2126                 SETTING_TRACE_DEBUG("PIN LOCK");
2127                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == result)
2128                         result_info.stat = SIM_PIN_LOCK_OFF_SUCCESS;
2129                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == result) {
2130                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
2131                         result_info.retry_cnt = sim_event_data->retry_count;
2132                 } else if (TAPI_SIM_PUK_REQUIRED == result)
2133                         result_info.stat = SIM_PIN1_BLOCKED;
2134
2135                 /*  Pre CCF */
2136                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == result
2137                          || TAPI_SIM_CARD_ERROR == result) {
2138                         /*  popup */
2139                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
2140                 }
2141                 else {
2142                         SETTING_TRACE_DEBUG
2143                             ("%s*** [ERR] INCORRECTED ***%s",
2144                              SETTING_FONT_RED,
2145                              SETTING_FONT_BLACK);
2146                         return;
2147                 }
2148         }
2149         setting_password_ug_display_result_popup(&result_info, user_data);
2150 }
2151
2152 static void setting_password_ug_display_result_popup(tapi_receive_info *result,
2153                                                      SettingPasswordUG *ad)
2154 {
2155         SETTING_TRACE_BEGIN;
2156         switch (result->stat) {
2157         case SIM_OPERATION_OK:
2158         case SIM_LOCK_ON_SUCCESS:
2159         case SIM_LOCK_OFF_SUCCESS:
2160         case SIM_PIN_LOCK_ON_SUCCESS:
2161         case SIM_PIN_LOCK_OFF_SUCCESS:
2162                 {
2163                         if (ad->view_type ==
2164                             SETTING_PW_TYPE_SIM_LOCK_OFF) {
2165                                 int err = SETTING_RETURN_SUCCESS;
2166                                 /*  reset VCONF */
2167                                 setting_set_int_slp_key
2168                                     (INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,
2169                                      SIM_LOCK_ATTEMPS_MAX, &err);
2170                                 setting_retm_if(err == SETTING_RETURN_FAIL,
2171                                                 "[Error] set value of vconf fail.");
2172                         }
2173                         /*  Success to Operate */
2174                         app_control_h svc;
2175                         if (app_control_create(&svc))
2176                                 return;
2177
2178                         app_control_add_extra_data(svc, "result", ad->view_type_string);
2179                         ug_send_result(ad->ug, svc);
2180                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
2181
2182                         app_control_destroy(svc);
2183                         /* Send destroy request */
2184                         ug_destroy_me(ad->ug);
2185                 }
2186                 break;
2187
2188         case SIM_PIN1_BLOCKED:
2189                 {
2190                         SETTING_TRACE_DEBUG("SIM_PIN1_BLOCKED");
2191                         //ad->view_type = SETTING_PW_TYPE_PIN_BLOCKED;
2192                         /*  Success to Operate */
2193                         app_control_h svc;
2194                         if (app_control_create(&svc))
2195                                 return;
2196
2197                         app_control_add_extra_data(svc, "result", "SETTING_PW_TYPE_PIN_BLOCKED");
2198                         ug_send_result(ad->ug, svc);
2199                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_PIN_BLOCKED");
2200
2201                         app_control_destroy(svc);
2202                         /* Send destroy request */
2203                         ug_destroy_me(ad->ug);
2204                 }
2205                 break;
2206         case SIM_PIN2_BLOCKED:
2207                 {
2208                         SETTING_TRACE_DEBUG("SIM_PIN2_BLOCKED");
2209                         //ad->view_type = SETTING_PW_TYPE_PIN2_BLOCKED;
2210                         app_control_h svc;
2211                         if (app_control_create(&svc))
2212                                 return;
2213
2214                         app_control_add_extra_data(svc, "result", "SETTING_PW_TYPE_PIN2_BLOCKED");
2215                         ug_send_result(ad->ug, svc);
2216                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_PIN2_BLOCKED");
2217
2218                         app_control_destroy(svc);
2219                         /* Send destroy request */
2220                         ug_destroy_me(ad->ug);
2221                         //safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN2_BLOCKED")+1);
2222                         //setting_password_ug_create_popup_notitle_nobtn(ad,
2223                         //                                             _("IDS_ST_POP_PIN2_BLOCKED"), TRUE);
2224                 }
2225                 break;
2226         case SIM_LOCK_INCORRECT_PASSWORD:
2227                 {
2228                         SETTING_TRACE_DEBUG("SIM LOCK INCORRECT PASSWORD");
2229                         ad->focus_data = ad->ed_pw1;
2230                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2231                 }
2232                 break;
2233         case SIM_INCORRECT_PIN1_CODE:
2234                 {
2235                         if(ad->view_type == SETTING_PW_TYPE_CHANGE_PIN)
2236                         {
2237                                 ad->incorrect_pin1_flag = TRUE;
2238                                 FREE(ad->cur_pwd);
2239                                 elm_genlist_clear(ad->scroller);
2240                                 ADD_GL_SEPARATOR(ad->scroller)
2241                                 setting_password_sim_draw_1line_entry(ad, NULL);
2242                                 ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
2243                                 return;
2244                         }
2245
2246                         const char *ret_str = NULL;
2247                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
2248
2249                         if (result->retry_cnt > 1) {
2250                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
2251                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2252                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_BODY_INCORRECT_PIN_E"), _(ATTEMPTS_DESC));
2253                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2254                                 setting_retm_if(ret < 0, "snprintf fail");
2255                                 ret_str = tmp_str;
2256                         } else {
2257                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2258                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_BODY_INCORRECT_PIN_E"), _(ATTEMPT_DESC));
2259                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2260                                 setting_retm_if(ret < 0, "snprintf fail");
2261                                 ret_str = tmp_str;
2262                                 //ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
2263                         }
2264
2265                         ad->focus_data = ad->ed_pw1;
2266 #ifdef SUPPORT_POPUP
2267                         setting_password_ug_create_popup_notitle_nobtn(ad, (char *)ret_str, FALSE);
2268 #else
2269                         setting_password_ug_display_desc(ad, (char *)ret_str, FALSE);
2270 #endif
2271                 }
2272                 break;
2273         case SIM_INCORRECT_PIN2_CODE:
2274                 {
2275                         if(ad->view_type == SETTING_PW_TYPE_CHANGE_PIN2)
2276                         {
2277                                 ad->incorrect_pin2_flag = TRUE;
2278                                 FREE(ad->cur_pwd);
2279                                 elm_genlist_clear(ad->scroller);
2280                                 ADD_GL_SEPARATOR(ad->scroller)
2281                                 setting_password_sim_draw_1line_entry(ad, NULL);
2282                                 ad->focus_timer = ecore_timer_add(0.5, __setting_password_sim_rotate_cb, ad);
2283                                 return;
2284                         }
2285
2286                         char *ret_str = NULL;
2287                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
2288
2289                         if (result->retry_cnt > 1) {
2290                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
2291                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2292                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PIN2"), _(ATTEMPTS_DESC));
2293                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2294                                 setting_retm_if(ret < 0, "snprintf fail");
2295                                 ret_str = tmp_str;
2296                         } else {
2297                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2298                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PIN2"), _(ATTEMPT_DESC));
2299                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2300                                 setting_retm_if(ret < 0, "snprintf fail");
2301                                 ret_str = tmp_str;
2302                                 //ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
2303                         }
2304
2305                         ad->focus_data = ad->ed_pw1;
2306 #ifdef SUPPORT_POPUP
2307                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
2308 #else
2309                         setting_password_ug_display_desc(ad, ret_str, FALSE);
2310 #endif
2311                 }
2312                 break;
2313         case SIM_INCORRECT_PUK1_CODE:
2314                 {
2315                         char *ret_str = NULL;
2316                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
2317
2318                         if (result->retry_cnt > 1) {
2319                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK1_PD_ATTEMPTS_LEFT', must transform */
2320                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK1_ERR_DESC, result->retry_cnt);
2321                                 setting_retm_if(ret < 0, "snprintf fail");
2322                                 ret_str = tmp_str;
2323                         } else {
2324                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK1_CODE");
2325                         }
2326
2327                         ad->focus_data = ad->ed_pw1;
2328 #ifdef SUPPORT_POPUP
2329                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
2330 #else
2331                         setting_password_ug_display_desc(ad, ret_str, FALSE);
2332 #endif
2333                 }
2334                 break;
2335         case SIM_INCORRECT_PUK2_CODE:
2336                 {
2337                         char *ret_str = NULL;
2338                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
2339
2340                         if (result->retry_cnt > 1) {
2341                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
2342                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2343                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PUK2"), _(ATTEMPTS_DESC));
2344                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2345                                 setting_retm_if(ret < 0, "snprintf fail");
2346                                 ret_str = tmp_str;
2347                         } else {
2348                                 char tmp_str2[SETTING_STR_SLP_LEN] = {0,};
2349                                 snprintf(tmp_str2, SETTING_STR_SLP_LEN, "%s. %s.", _("IDS_ST_POP_INCORRECT_PUK2"), _(ATTEMPT_DESC));
2350                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, tmp_str2, result->retry_cnt);
2351                                 setting_retm_if(ret < 0, "snprintf fail");
2352                                 ret_str = tmp_str;
2353                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
2354                         }
2355                         ad->focus_data = ad->ed_pw1;
2356 #ifdef SUPPORT_POPUP
2357                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
2358 #else
2359                         setting_password_ug_display_desc(ad, ret_str, FALSE);
2360 #endif
2361                 }
2362                 break;
2363
2364         case SIM_PIN1_CHANGE_SUCCESS:
2365                 {
2366                         SETTING_TRACE_DEBUG("SIM_PIN1_CHANGE_SUCCESS");
2367                         //ad->view_type = SETTING_PW_TYPE_PIN_BLOCKED;
2368                         /*  Success to Operate */
2369                         app_control_h svc;
2370                         if (app_control_create(&svc))
2371                                 return;
2372
2373                         app_control_add_extra_data(svc, "result", ad->view_type_string);
2374                         ug_send_result(ad->ug, svc);
2375                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
2376
2377                         app_control_destroy(svc);
2378                         /* Send destroy request */
2379                         ug_destroy_me(ad->ug);
2380                 }
2381                 //setting_password_ug_create_popup_notitle_nobtn(ad,
2382                 //                                             _("IDS_ST_POP_PIN1_CHANGED"), TRUE);
2383                 break;
2384         case SIM_PIN2_CHANGE_SUCCESS:
2385                 setting_password_ug_create_popup_notitle_nobtn(ad,
2386                                                                _("IDS_ST_POP_PIN2_CHANGED"), TRUE);
2387                 break;
2388         case SIM_PIN1_UNBLOCKED:
2389                 SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
2390                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN_LOCK_ON", safeStrLen("SETTING_PW_TYPE_PIN_LOCK_ON")+1);
2391                 setting_password_ug_create_popup_notitle_nobtn(ad,
2392                                                                _("IDS_ST_POP_PIN_UNBLOCKED"), TRUE);
2393                 break;
2394         case SIM_PIN2_UNBLOCKED:
2395                 setting_password_ug_create_popup_notitle_nobtn(ad,
2396                                                                _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
2397                 break;
2398         case SIM_PUK1_BLOCKED:
2399                 {
2400                         char *ret_str = NULL;
2401                         ret_str = PUK1_BLOCKED;
2402
2403                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PUK1_BLOCKED", safeStrLen("SETTING_PW_TYPE_PUK1_BLOCKED")+1);
2404                         setting_password_ug_create_popup_notitle_nobtn(ad,
2405                                                ret_str, TRUE);
2406                         /*  Phone blocked. Call Permernent UG */
2407                 }
2408                 break;
2409         case SIM_PUK2_BLOCKED:
2410                 {
2411                         app_control_h svc;
2412                         if (app_control_create(&svc))
2413                                 return;
2414
2415                         app_control_add_extra_data(svc, "result", "SETTING_PW_TYPE_PUK2_BLOCKED");
2416                         ug_send_result(ad->ug, svc);
2417                         SETTING_TRACE("Send Result : %s\n", "SETTING_PW_TYPE_PUK2_BLOCKED");
2418
2419                         app_control_destroy(svc);
2420                         /* Send destroy request */
2421                         ug_destroy_me(ad->ug);
2422                 }
2423                 /*  Call Permernent UG */
2424                 break;
2425         case SIM_REQUIRED_PUK_CODE:
2426                 SETTING_TRACE_DEBUG("SIM_REQUIRED_PUK_CODE");
2427                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN_BLOCKED")+1);
2428                 setting_password_ug_create_popup_notitle_nobtn(ad,
2429                                        _("IDS_ST_POP_PIN1_BLOCKED"), TRUE);
2430                 break;
2431         case SIM_OPERATION_UNAVAILABLE:
2432                 setting_password_ug_create_popup_notitle_nobtn(ad,
2433                                        _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
2434                 break;
2435         case SIM_UNKNOWN_ERROR:
2436                 setting_password_ug_create_popup_notitle_nobtn(ad,
2437                                        _("IDS_CST_POP_UNKNOWN_OPERATION"), FALSE);
2438                 break;
2439         case SIM_ERROR:
2440         case SIM_REQ_PIN:
2441         case SIM_OPERATION_OFF:
2442         case SIM_LOCK_ON_FAIL:
2443                 SETTING_TRACE_DEBUG("SIM_LOCK_ON_FAIL");
2444                 {
2445                         if(result->retry_cnt > 0)
2446                         {
2447                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
2448                         }
2449                         else
2450                         {
2451                                 char tmp_str[SETTING_STR_SLP_LEN] = {0,};
2452                                 snprintf(tmp_str, SETTING_STR_SLP_LEN, PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
2453                                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_SIM_LOCK_DISABLE", safeStrLen("SETTING_PW_TYPE_SIM_LOCK_DISABLE")+1);
2454                                 setting_password_ug_create_popup_notitle_nobtn(ad, tmp_str, TRUE);
2455                         }
2456                 }
2457                 break;
2458         case SIM_PIN1_CHANGE_FAIL:
2459         case SIM_PIN2_CHANGE_FAIL:
2460                 setting_password_ug_create_popup_notitle_nobtn(ad,
2461                                        _("Change Failed"), TRUE);
2462                 break;
2463         default:
2464                 break;
2465         }
2466
2467         SETTING_TRACE_END;
2468 }