setting-password/src/setting-password.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 #include <setting-password.h>
  22 #include <security-server.h>
  23
  24 #ifndef UG_MODULE_API
  25 #define UG_MODULE_API __attribute__ ((visibility("default")))
  26 #endif
  27
  28 static struct _pw_item pw_its[] = {
  29         { SETTING_PW_TYPE_SIM_LOCK_ON, "SETTING_PW_TYPE_SIM_LOCK_ON" },
  30         { SETTING_PW_TYPE_SIM_LOCK_OFF, "SETTING_PW_TYPE_SIM_LOCK_OFF" },
  31         { SETTING_PW_TYPE_PIN_LOCK_ON, "SETTING_PW_TYPE_PIN_LOCK_ON" },
  32         { SETTING_PW_TYPE_PIN_LOCK_OFF, "SETTING_PW_TYPE_PIN_LOCK_OFF" },
  33         { SETTING_PW_TYPE_CHANGE_PIN1, "SETTING_PW_TYPE_CHANGE_PIN1" },
  34         { SETTING_PW_TYPE_CHANGE_PIN2, "SETTING_PW_TYPE_CHANGE_PIN2" },
  35         { SETTING_PW_TYPE_PIN1_BLOCKED, "SETTING_PW_TYPE_PIN1_BLOCKED" },
  36         { SETTING_PW_TYPE_PIN2_BLOCKED, "SETTING_PW_TYPE_PIN2_BLOCKED" },
  37         { SETTING_PW_TYPE_RESET, "SETTING_PW_TYPE_RESET" },
  38         { SETTING_PW_TYPE_MAX, NULL }
  39 };
  40
  41 static void setting_tapi_init(SettingPasswordUG *ad);
  42 static void setting_password_ug_display_result_popup(tapi_receive_info *result, SettingPasswordUG *ad);
  43
  44 static void setting_password_ug_cb_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
  45 {
  46         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  47         setting_view_update(&setting_view_password_main, ad);
  48 }
  49
  50 static void setting_tapi_init(SettingPasswordUG *ad)
  51 {
  52         SETTING_TRACE_BEGIN;
  53         switch (ad->view_type) {
  54         case SETTING_PW_TYPE_SIM_LOCK_ON:
  55         case SETTING_PW_TYPE_SIM_LOCK_OFF:
  56         case SETTING_PW_TYPE_PIN_LOCK_ON:
  57         case SETTING_PW_TYPE_PIN_LOCK_OFF:
  58         case SETTING_PW_TYPE_CHANGE_PIN1:
  59         case SETTING_PW_TYPE_CHANGE_PIN2:
  60         case SETTING_PW_TYPE_PIN1_BLOCKED:
  61         case SETTING_PW_TYPE_PIN2_BLOCKED:
  62                 ad->handle =  tel_init(NULL);
  63                 if (!ad->handle) {
  64                         SETTING_TRACE_DEBUG("%s*** [ERR] tel_init. ***%s",
  65                              SETTING_FONT_RED, SETTING_FONT_BLACK);
  66                         setting_password_ug_create_popup_notitle_nobtn(ad,
  67                                                                        _("IDS_COM_POP_ERROR"),
  68                                                                        FALSE);
  69                 }
  70
  71                 break;
  72         default:
  73                 break;
  74         }
  75         SETTING_TRACE_END;
  76 }
  77
  78 static void setting_tapi_finize(SettingPasswordUG *ad)
  79 {
  80         SETTING_TRACE_BEGIN;
  81         switch (ad->view_type) {
  82         case SETTING_PW_TYPE_SIM_LOCK_ON:
  83         case SETTING_PW_TYPE_SIM_LOCK_OFF:
  84         case SETTING_PW_TYPE_PIN_LOCK_ON:
  85         case SETTING_PW_TYPE_PIN_LOCK_OFF:
  86         case SETTING_PW_TYPE_CHANGE_PIN1:
  87         case SETTING_PW_TYPE_CHANGE_PIN2:
  88         case SETTING_PW_TYPE_PIN1_BLOCKED:
  89         case SETTING_PW_TYPE_PIN2_BLOCKED:
  90                 if (tel_deinit(ad->handle) != TAPI_API_SUCCESS) {
  91                         SETTING_TRACE_DEBUG
  92                             ("%s*** [ERR] setting_network_unsubscribe_tapi_events. ***%s",
  93                              SETTING_FONT_RED, SETTING_FONT_BLACK);
  94                         setting_password_ug_create_popup_notitle_nobtn(ad,
  95                                                                        _("IDS_COM_POP_ERROR"),
  96                                                                        FALSE);
  97                 }
  98                 break;
  99         default:
 100                 break;
 101         }
 102         SETTING_TRACE_END;
 103 }
 104
 105 setting_pw_type __get_password_view_type(SettingPasswordUG *ad, service_h service)
 106 {
 107         SETTING_TRACE_BEGIN;
 108
 109         service_get_extra_data(service, "viewtype", &(ad->view_type_string));
 110
 111         SETTING_TRACE("viewtype:%s", ad->view_type_string);
 112         setting_pw_type ret_pw_type = 0;
 113         int i;
 114
 115         for(i = 0; i < SETTING_PW_TYPE_MAX; i++)
 116         {
 117                 if (0 == safeStrCmp(ad->view_type_string, pw_its[i].pw_type_string))
 118                 {
 119                         ret_pw_type = pw_its[i].pw_type_num;
 120                         break;
 121                 }
 122         }
 123
 124         /* end */
 125
 126         return ret_pw_type;
 127 }
 128
 129 static char *__gl_err_desc_text_get(void *data, Evas_Object *obj, const char *part)
 130 {
 131         retv_if(data == NULL, NULL);
 132         char buf[256] = {0,};
 133
 134         snprintf(buf, sizeof(buf)-1, "<font color=#ff0000>%s</font>", (char*)data);
 135
 136         return strdup(buf);
 137 }
 138
 139 static void *setting_password_ug_on_create(ui_gadget_h ug,
 140                                            enum ug_mode mode, service_h service,
 141                                            void *priv)
 142 {
 143         setting_retvm_if((!priv), NULL, "!priv");
 144
 145         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 146         passwordUG->ug = ug;
 147         passwordUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 148         passwordUG->win_get = (Evas_Object *) ug_get_window();
 149         evas_object_show(passwordUG->win_main_layout);
 150         passwordUG->evas = evas_object_evas_get(passwordUG->win_main_layout);
 151
 152         setting_retvm_if(passwordUG->win_main_layout == NULL, NULL,
 153                          "cannot get main window ");
 154
 155         /* --------------------------------------------------------- */
 156         char *pa_path = NULL;;
 157
 158         pa_path = vconf_get_str(VCONFKEY_LANGSET);
 159         if (!pa_path) {
 160                 SETTING_TRACE
 161                     ("%s*** language setting has no proper value (nil) ***%s",
 162                      SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 163                 return NULL;
 164         }
 165         /* set launguage */
 166         setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 167         FREE(pa_path);
 168
 169         setting_create_Gendial_itc("dialogue/1icon",&(passwordUG->itc_variable_height));
 170         passwordUG->itc_seperator.item_style = "dialogue/separator/21/with_line";
 171         passwordUG->itc_seperator.func.text_get = NULL;
 172         passwordUG->itc_seperator.func.content_get = NULL;
 173         passwordUG->itc_seperator.func.state_get = NULL;
 174         passwordUG->itc_seperator.func.del = NULL;
 175
 176         passwordUG->itc_err_desc.item_style = "multiline/1text";
 177         passwordUG->itc_err_desc.func.text_get = __gl_err_desc_text_get;
 178         passwordUG->itc_err_desc.func.content_get = NULL;
 179         passwordUG->itc_err_desc.func.state_get = NULL;
 180         passwordUG->itc_err_desc.func.del = NULL;
 181
 182         /* init */
 183         passwordUG->view_type = __get_password_view_type(passwordUG, service);
 184         setting_tapi_init(passwordUG);
 185
 186         /*  creating a view. */
 187         setting_view_create(&setting_view_password_main,(void *)passwordUG);
 188         evas_object_event_callback_add(passwordUG->win_main_layout,
 189                                                EVAS_CALLBACK_RESIZE,
 190                                                setting_password_ug_cb_resize,
 191                                                passwordUG);
 192         return passwordUG->ly_main;
 193 }
 194
 195 static void setting_password_ug_on_start(ui_gadget_h ug, service_h service, void *priv)
 196 {
 197 }
 198
 199 static void setting_password_ug_on_pause(ui_gadget_h ug, service_h service, void *priv)
 200 {
 201 }
 202
 203 static void setting_password_ug_on_resume(ui_gadget_h ug, service_h service, void *priv)
 204 {
 205 }
 206
 207 static void setting_password_ug_on_destroy(ui_gadget_h ug, service_h service, void *priv)
 208 {
 209         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 210
 211         evas_object_event_callback_del(passwordUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_password_ug_cb_resize);       /* fix flash issue for gallery */
 212         passwordUG->ug = ug;
 213         setting_tapi_finize(passwordUG);
 214
 215         if (passwordUG->t_info) {
 216                 FREE(passwordUG->t_info);
 217         }
 218         if(passwordUG->remove_timer)
 219         {
 220                 ecore_timer_del(passwordUG->remove_timer);
 221                 passwordUG->remove_timer = NULL;
 222         }
 223
 224         /*  delete the allocated objects. */
 225         setting_view_destroy(&setting_view_password_main, passwordUG);
 226         if (NULL != ug_get_layout(passwordUG->ug)) {
 227                 evas_object_hide((Evas_Object *) ug_get_layout(passwordUG->ug));
 228                 evas_object_del((Evas_Object *) ug_get_layout(passwordUG->ug));
 229         }
 230 }
 231
 232 static void setting_password_ug_on_message(ui_gadget_h ug, service_h msg,
 233                                            service_h service, void *priv)
 234 {
 235
 236 }
 237
 238 static void setting_password_ug_on_event(ui_gadget_h ug,
 239                                          enum ug_event event, service_h service,
 240                                          void *priv)
 241 {
 242         switch (event) {
 243         case UG_EVENT_LOW_MEMORY:
 244                 break;
 245         case UG_EVENT_LOW_BATTERY:
 246                 break;
 247         case UG_EVENT_LANG_CHANGE:
 248                 break;
 249         case UG_EVENT_ROTATE_PORTRAIT:
 250                 break;
 251         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 252                 break;
 253         case UG_EVENT_ROTATE_LANDSCAPE:
 254                 break;
 255         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 256                 break;
 257         case UG_EVENT_REGION_CHANGE:
 258                 break;
 259         default:
 260                 break;
 261         }
 262 }
 263
 264 static void setting_password_ug_on_key_event(ui_gadget_h ug,
 265                                              enum ug_key_event event,
 266                                              service_h service, void *priv)
 267 {
 268         if (!priv)
 269                 return;
 270
 271         SettingPasswordUG *ad = (SettingPasswordUG*)priv;
 272
 273         switch (event) {
 274         case UG_KEY_EVENT_END:
 275                 if(ad->remove_timer)
 276                 {
 277                         ecore_timer_del(ad->remove_timer);
 278                         ad->remove_timer = NULL;
 279                 }
 280                 ug_destroy_me(ug);
 281                 break;
 282         default:
 283                 break;
 284         }
 285 }
 286
 287 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 288 {
 289         SettingPasswordUG *passwordUG = calloc(1, sizeof(SettingPasswordUG));
 290         setting_retvm_if(!passwordUG, -1, "Create SettingPasswordUG obj failed");
 291
 292         ops->create = setting_password_ug_on_create;
 293         ops->start = setting_password_ug_on_start;
 294         ops->pause = setting_password_ug_on_pause;
 295         ops->resume = setting_password_ug_on_resume;
 296         ops->destroy = setting_password_ug_on_destroy;
 297         ops->message = setting_password_ug_on_message;
 298         ops->event = setting_password_ug_on_event;
 299         ops->key_event = setting_password_ug_on_key_event;
 300         ops->priv = passwordUG;
 301         ops->opt = UG_OPT_INDICATOR_ENABLE;
 302
 303         return 0;
 304 }
 305
 306 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 307 {
 308         struct SettingPasswordUG *passwordUG;
 309         setting_retm_if(!ops, "ops == NULL");
 310
 311         passwordUG = ops->priv;
 312         if (passwordUG)
 313                 FREE(passwordUG);
 314 }
 315
 316 void setting_sim_change_pins_cb(TapiHandle *handle, int result, void *data, void *user_data)
 317 {
 318         SETTING_TRACE_BEGIN;
 319         ret_if(!user_data || !data);
 320         TelSimPinOperationResult_t sec_rt = result;
 321         tapi_receive_info result_info = { 0, };
 322         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 323         SETTING_TRACE("sec_rt[%d]", sec_rt);
 324         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 325         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 326
 327         if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt) {
 328                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 329                         result_info.stat = SIM_PIN1_CHANGE_SUCCESS;
 330                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 331                         result_info.stat = SIM_PIN2_CHANGE_SUCCESS;
 332         } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 333                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 334                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 335                         result_info.retry_cnt = sim_event_data->retry_count;
 336                 } else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type) {
 337                         result_info.stat = SIM_INCORRECT_PIN2_CODE;
 338                         result_info.retry_cnt = sim_event_data->retry_count;
 339                 }
 340         } else if (TAPI_SIM_PUK_REQUIRED == sec_rt) {
 341                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 342                         result_info.stat = SIM_PIN1_BLOCKED;
 343                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 344                         result_info.stat = SIM_PIN2_BLOCKED;
 345         } else {
 346                 SETTING_TRACE_DEBUG
 347                     ("%s*** [ERR] INCORRECTED ***%s",
 348                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 349                 return;
 350         }
 351         setting_password_ug_display_result_popup(&result_info, user_data);
 352 }
 353
 354 void setting_sim_verify_puks_cb(TapiHandle *handle, int result, void *data, void *user_data)
 355 {
 356         SETTING_TRACE_BEGIN;
 357
 358         ret_if(!user_data || !data);
 359         SettingPasswordUG *ad = user_data;
 360         TelSimPinOperationResult_t sec_rt = result;
 361         tapi_receive_info result_info = { 0, };
 362         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 363         ad->verify_puks_result = sim_event_data;
 364         SETTING_TRACE("sec_rt[%d]", sec_rt);
 365         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 366         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 367
 368         if (TAPI_SIM_PTYPE_PUK1 == sim_event_data->type)
 369         {
 370                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 371                         SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
 372                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN1_UNBLOCKED")+1);
 373                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK1 Sucessfully"), TRUE);
 374                         return;
 375                 } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 376                         result_info.stat = SIM_INCORRECT_PUK1_CODE;
 377                         result_info.retry_cnt = sim_event_data->retry_count;
 378                 } else {
 379                         result_info.stat = SIM_UNKNOWN_ERROR;
 380                 }
 381         }
 382
 383         else if (TAPI_SIM_PTYPE_PUK2 == sim_event_data->type)
 384         {
 385                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 386                         SETTING_TRACE_DEBUG("SIM_PIN2_UNBLOCKED");
 387                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN2_UNBLOCKED")+1);
 388                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK2 Sucessfully"), TRUE);
 389                         return;
 390                 } else if (TAPI_SIM_PUK_INCORRECT_PASSWORD == sec_rt) {
 391                         result_info.stat = SIM_INCORRECT_PUK2_CODE;
 392                         result_info.retry_cnt = sim_event_data->retry_count;
 393                 } else {
 394                         result_info.stat = SIM_UNKNOWN_ERROR;
 395                 }
 396         }
 397         else
 398         {
 399                 result_info.stat = SIM_UNKNOWN_ERROR;
 400         }
 401         setting_password_ug_display_result_popup(&result_info, user_data);
 402 }
 403
 404 void setting_sim_facility_enable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 405 {
 406         SETTING_TRACE_BEGIN;
 407         ret_if(!user_data || !data);
 408         TelSimPinOperationResult_t sec_rt = result;
 409         tapi_receive_info result_info = { 0, };
 410         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 411
 412         SETTING_TRACE("sec_rt[%d]", sec_rt);
 413         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 414         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 415
 416         /*  Sim Lock  */
 417         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 418                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_SIM == sim_event_data->type");
 419                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 420                         result_info.stat = SIM_LOCK_ON_SUCCESS;
 421                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 422                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 423                 else {
 424                         SETTING_TRACE_DEBUG("%s*** [ERR] INCORRECTED ***%s",
 425                              SETTING_FONT_RED,
 426                              SETTING_FONT_BLACK);
 427                         return;
 428                 }
 429         }
 430         /*  Pin Lock */
 431         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 432                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_PIN1 == sim_event_data->type");
 433                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 434                         result_info.stat = SIM_PIN_LOCK_ON_SUCCESS;
 435                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 436                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 437                         result_info.retry_cnt = sim_event_data->retry_count;
 438                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 439                         result_info.stat = SIM_PIN1_BLOCKED;
 440
 441                 /*  Pre CCF */
 442                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 443                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 444                         /*  popup */
 445                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 446                 }
 447                 else {
 448                         SETTING_TRACE_DEBUG
 449                             ("%s*** [ERR] INCORRECTED ***%s",
 450                              SETTING_FONT_RED,
 451                              SETTING_FONT_BLACK);
 452                         return;
 453                 }
 454         }
 455         setting_password_ug_display_result_popup(&result_info, user_data);
 456 }
 457 void setting_sim_facility_disable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 458 {
 459         SETTING_TRACE_BEGIN;
 460         ret_if(!user_data || !data);
 461         TelSimPinOperationResult_t sec_rt = result;
 462         tapi_receive_info result_info = { 0, };
 463         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 464         SETTING_TRACE("sec_rt[%d]", sec_rt);
 465         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 466         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 467
 468         /*  Sim Lock  */
 469         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 470                 SETTING_TRACE_DEBUG("SIM lOCK");
 471                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 472                         result_info.stat = SIM_LOCK_OFF_SUCCESS;
 473                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 474                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 475                 else {
 476                         SETTING_TRACE_DEBUG
 477                             ("%s*** [ERR] INCORRECTED ***%s",
 478                              SETTING_FONT_RED,
 479                              SETTING_FONT_BLACK);
 480                         return;
 481                 }
 482         }
 483         /*  Pin Lock */
 484         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 485                 SETTING_TRACE_DEBUG("PIN LOCK");
 486                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 487                         result_info.stat = SIM_PIN_LOCK_OFF_SUCCESS;
 488                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 489                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 490                         result_info.retry_cnt = sim_event_data->retry_count;
 491                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 492                         result_info.stat = SIM_PIN1_BLOCKED;
 493
 494                 /*  Pre CCF */
 495                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 496                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 497                         /*  popup */
 498                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 499                 }
 500                 else {
 501                         SETTING_TRACE_DEBUG
 502                             ("%s*** [ERR] INCORRECTED ***%s",
 503                              SETTING_FONT_RED,
 504                              SETTING_FONT_BLACK);
 505                         return;
 506                 }
 507         }
 508         setting_password_ug_display_result_popup(&result_info, user_data);
 509 }
 510
 511 static void setting_password_ug_display_result_popup(tapi_receive_info *result,
 512                                                      SettingPasswordUG *ad)
 513 {
 514         switch (result->stat) {
 515         case SIM_OPERATION_OK:
 516         case SIM_LOCK_ON_SUCCESS:
 517         case SIM_LOCK_OFF_SUCCESS:
 518         case SIM_PIN_LOCK_ON_SUCCESS:
 519         case SIM_PIN_LOCK_OFF_SUCCESS:
 520                 {
 521                         if (ad->view_type ==
 522                             SETTING_PW_TYPE_SIM_LOCK_OFF) {
 523                                 int err = SETTING_RETURN_SUCCESS;
 524                                 /*  reset VCONF */
 525                                 setting_set_int_slp_key
 526                                     (INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,
 527                                      SIM_LOCK_ATTEMPS_MAX, &err);
 528                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 529                                                 "[Error] set value of vconf fail.");
 530                         }
 531                         /*  Success to Operate */
 532                         service_h svc;
 533                         if (service_create(&svc))
 534                                 return;
 535
 536                         service_add_extra_data(svc, "result", ad->view_type_string);
 537                         ug_send_result(ad->ug, svc);
 538                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 539
 540                         service_destroy(svc);
 541                         /* Send destroy request */
 542                         ug_destroy_me(ad->ug);
 543                 }
 544                 break;
 545         case SIM_LOCK_INCORRECT_PASSWORD:
 546                 ad->focus_data = ad->ed_pw1;
 547                 setting_password_ug_check_attemps_left(ad);
 548                 break;
 549         case SIM_INCORRECT_PIN1_CODE:
 550                 {
 551                         const char *ret_str = NULL;
 552                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 553
 554                         if (result->retry_cnt > 1) {
 555                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 556                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 557                                 setting_retm_if(ret < 0, "snprintf fail");
 558                                 ret_str = tmp_str;
 559                         } else {
 560                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 561                                 setting_retm_if(ret < 0, "snprintf fail");
 562                                 ret_str = tmp_str;
 563                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 564                         }
 565                         ad->focus_data = ad->ed_pw1;
 566
 567                         setting_password_ug_display_desc(ad, (char *)ret_str, FALSE);
 568
 569                 }
 570                 break;
 571         case SIM_INCORRECT_PIN2_CODE:
 572                 {
 573                         char *ret_str = NULL;
 574                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 575
 576                         if (result->retry_cnt > 1) {
 577                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 578                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 579                                 setting_retm_if(ret < 0, "snprintf fail");
 580                                 ret_str = tmp_str;
 581                         } else {
 582                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 583                         }
 584                         ad->focus_data = ad->ed_pw1;
 585
 586                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 587
 588                 }
 589                 break;
 590         case SIM_INCORRECT_PUK1_CODE:
 591                 {
 592                         char *ret_str = NULL;
 593                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 594
 595                         if (result->retry_cnt > 1) {
 596                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK1_PD_ATTEMPTS_LEFT', must transform */
 597                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK1_ERR_DESC, result->retry_cnt);
 598                                 setting_retm_if(ret < 0, "snprintf fail");
 599                                 ret_str = tmp_str;
 600                         } else {
 601                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK1_CODE");
 602                         }
 603                         ad->focus_data = ad->ed_pw1;
 604
 605                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 606
 607                 }
 608                 break;
 609         case SIM_INCORRECT_PUK2_CODE:
 610                 {
 611                         char *ret_str = NULL;
 612                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 613                         if (result->retry_cnt > 1) {
 614                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK2_PD_ATTEMPTS_LEFT', must transform*/
 615                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK2_ERR_DESC, result->retry_cnt);
 616                                 setting_retm_if(ret < 0, "snprintf fail");
 617                                 ret_str = tmp_str;
 618                         } else {
 619                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK2");
 620                         }
 621                         ad->focus_data = ad->ed_pw1;
 622
 623                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 624
 625                 }
 626                 break;
 627         case SIM_PIN1_CHANGE_SUCCESS:
 628                 setting_password_ug_create_popup_notitle_nobtn(ad,
 629                                                                _("IDS_ST_POP_PIN1_CHANGED"), TRUE);
 630                 break;
 631         case SIM_PIN2_CHANGE_SUCCESS:
 632                 setting_password_ug_create_popup_notitle_nobtn(ad,
 633                                                                _("IDS_ST_POP_PIN2_CHANGED"), TRUE);
 634                 break;
 635         case SIM_PIN1_BLOCKED:
 636                 SETTING_TRACE_DEBUG("SIM_PIN1_BLOCKED");
 637                 ad->view_type = SETTING_PW_TYPE_PIN1_BLOCKED;
 638                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN1_BLOCKED")+1);
 639                 setting_password_ug_create_popup_notitle_nobtn(ad,
 640                                                                _("IDS_ST_POP_PIN1_BLOCKED"), FALSE);
 641                 break;
 642         case SIM_PIN2_BLOCKED:
 643                 SETTING_TRACE_DEBUG("SIM_PIN2_BLOCKED");
 644                 ad->view_type = SETTING_PW_TYPE_PIN2_BLOCKED;
 645                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN2_BLOCKED")+1);
 646                 setting_password_ug_create_popup_notitle_nobtn(ad,
 647                                                                _("IDS_ST_POP_PIN2_BLOCKED"), FALSE);
 648                 break;
 649         case SIM_PIN1_UNBLOCKED:
 650                 SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
 651                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN_LOCK_ON", sizeof("SETTING_PW_TYPE_PIN_LOCK_ON")+1);
 652                 setting_password_ug_create_popup_notitle_nobtn(ad,
 653                                                                _("IDS_ST_POP_PIN_UNBLOCKED"), TRUE);
 654                 break;
 655         case SIM_PIN2_UNBLOCKED:
 656                 setting_password_ug_create_popup_notitle_nobtn(ad,
 657                                                                _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
 658                 break;
 659         case SIM_PUK1_BLOCKED:
 660                 setting_password_ug_create_popup_notitle_nobtn(ad,
 661                                        _("IDS_ST_BODY_PUK1_BLOCKED"), TRUE);
 662                 /*  Phone blocked. Call Permernent UG */
 663                 break;
 664         case SIM_PUK2_BLOCKED:
 665                 setting_password_ug_create_popup_notitle_nobtn(ad,
 666                                        _("IDS_ST_BODY_PUK2_BLOCKED"), TRUE);
 667                 /*  Call Permernent UG */
 668                 break;
 669         case SIM_REQUIRED_PUK_CODE:
 670                 SETTING_TRACE_DEBUG("SIM_REQUIRED_PUK_CODE");
 671                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_BLOCKED", sizeof("SETTING_PW_TYPE_PIN1_BLOCKED")+1);
 672                 setting_password_ug_create_popup_notitle_nobtn(ad,
 673                                        _("IDS_ST_POP_PIN1_BLOCKED"), TRUE);
 674                 break;
 675         case SIM_OPERATION_UNAVAILABLE:
 676                 setting_password_ug_create_popup_notitle_nobtn(ad,
 677                                        _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
 678                 break;
 679         case SIM_UNKNOWN_ERROR:
 680                 setting_password_ug_create_popup_notitle_nobtn(ad,
 681                                        _("IDS_ST_POP_UNKNOWN_OPERATION"), FALSE);
 682                 break;
 683         case SIM_ERROR:
 684         case SIM_REQ_PIN:
 685         case SIM_OPERATION_OFF:
 686         case SIM_LOCK_ON_FAIL:
 687                 SETTING_TRACE_DEBUG("SIM_LOCK_ON_FAIL");
 688                 {
 689                         int err = SETTING_RETURN_SUCCESS;
 690
 691                         if(result->retry_cnt > 0)
 692                         {
 693                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 694                         }
 695                         else
 696                         {
 697                                 char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 698                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
 699                                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_SIM_LOCK_DISABLE", sizeof("SETTING_PW_TYPE_SIM_LOCK_DISABLE")+1);
 700                                 setting_password_ug_create_popup_notitle_nobtn(ad, tmp_str, TRUE);
 701                         }
 702                 }
 703         case SIM_PIN1_CHANGE_FAIL:
 704         case SIM_PIN2_CHANGE_FAIL:
 705                 setting_password_ug_create_popup_notitle_nobtn(ad,
 706                                        _("Change Failed"), TRUE);
 707                 break;
 708         default:
 709                 break;
 710         }
 711
 712         SETTING_TRACE_END;
 713 }
 714
 715 void setting_password_ug_popup_resp_cb(void *data, Evas_Object *obj,
 716                                        void *event_info)
 717 {
 718         retm_if(data == NULL, "Data parameter is NULL");
 719
 720         service_h svc;
 721         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 722         if (ad->destroy) {
 723                 /*  Success to Operate */
 724
 725                 if (service_create(&svc))
 726                         return;
 727
 728                 service_add_extra_data(svc, "result", ad->view_type_string);
 729                 ug_send_result(ad->ug, svc);
 730                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 731
 732                 service_destroy(svc);
 733                 /* Send destroy request */
 734                 ug_destroy_me(ad->ug);
 735         } else {
 736                 char *diable_view_type = NULL;
 737                 if (ad->view_type == SETTING_PW_TYPE_PIN1_BLOCKED)
 738                 {
 739                         setting_view_destroy(&setting_view_password_main, ad);
 740                         setting_view_create(&setting_view_password_main, ad);
 741                         return;
 742                 }
 743                 else if (ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
 744                 {
 745                         setting_view_destroy(&setting_view_password_main, ad);
 746                         setting_view_create(&setting_view_password_main, ad);
 747                         return;
 748                 }
 749
 750                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
 751                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
 752                 }
 753
 754                 if (diable_view_type) {
 755                         /*  Success to Operate */
 756
 757                         if (service_create(&svc))
 758                                 return;
 759
 760                         service_add_extra_data(svc, "result", diable_view_type);
 761                         ug_send_result(ad->ug, svc);
 762
 763                         service_destroy(svc);
 764                         /* Send destroy request */
 765                         ug_destroy_me(ad->ug);
 766                 }
 767                 if (ad->focus_data) {
 768                         ad->focus_data->isFocusFlag = TRUE;
 769                         elm_object_item_data_set(ad->focus_data->item, ad->focus_data);
 770                         elm_genlist_item_update(ad->focus_data->item);
 771                 }
 772         }
 773 }
 774 static Eina_Bool __remove_desc(void *data)
 775 {
 776         SETTING_TRACE_BEGIN;
 777         retv_if(data == NULL, EINA_FALSE);
 778
 779         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 780
 781         if(ad->err_desc)
 782         {
 783                 elm_object_item_del(ad->err_desc);
 784                 ad->err_desc = NULL;
 785         }
 786
 787         if(ad->remove_timer)
 788         {
 789                 ecore_timer_del(ad->remove_timer);
 790                 ad->remove_timer = NULL;
 791         }
 792
 793         if (ad->destroy) {
 794                 /*  Success to Operate */
 795
 796                 service_h svc;
 797                 if (service_create(&svc))
 798                         return EINA_FALSE;
 799
 800                 service_add_extra_data(svc, "result", ad->view_type_string);
 801                 ug_send_result(ad->ug, svc);
 802                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 803
 804                 service_destroy(svc);
 805                 /* Send destroy request */
 806                 ug_destroy_me(ad->ug);
 807         } else {
 808                 char *diable_view_type = NULL;
 809                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
 810                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
 811                 }
 812
 813                 if (diable_view_type) {
 814                         /*  Success to Operate */
 815
 816                         service_h svc;
 817                         if (service_create(&svc))
 818                                 return EINA_FALSE;
 819
 820                         service_add_extra_data(svc, "result", diable_view_type);
 821                         ug_send_result(ad->ug, svc);
 822
 823                         service_destroy(svc);
 824                         /* Send destroy request */
 825                         ug_destroy_me(ad->ug);
 826                 }
 827         }
 828         return ECORE_CALLBACK_CANCEL;
 829 }
 830
 831 void setting_password_ug_display_desc(void *data, char *desc, int destroy)
 832 {
 833         SETTING_TRACE_BEGIN;
 834         ret_if(data == NULL || desc == NULL);
 835
 836         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 837
 838 #ifdef SUPPORT_MDM
 839         if(ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
 840                 return;
 841 #endif
 842
 843         ad->destroy = destroy;
 844
 845         if(ad->scroller == NULL)
 846                 return;
 847
 848         if(ad->err_desc)
 849         {
 850                 elm_object_item_del(ad->err_desc);
 851                 ad->err_desc = NULL;
 852         }
 853
 854         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), desc, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 855         ad->remove_timer = ecore_timer_add(2.0, __remove_desc, ad);
 856
 857         /* if pw incorrect, show keyboard again. */
 858         if(ad->ed_pw1)
 859         {
 860                 SETTING_TRACE_DEBUG("FOCUS IN");
 861                 ad->ed_pw1->isFocusFlag = TRUE;
 862                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 863         }
 864 }
 865
 866 void
 867 setting_password_ug_create_popup_notitle_nobtn(void *data, char *str,
 868                                                int destroy)
 869 {
 870         /* error check */
 871         retm_if(data == NULL, "Data parameter is NULL");
 872
 873         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 874
 875         ad->destroy = destroy;
 876         if(ad->notify)
 877         {
 878                 evas_object_del(ad->notify);
 879                 ad->notify = NULL;
 880         }
 881         ad->notify = setting_create_popup_without_btn(ad, ad->ly_main, NULL, str,
 882                                           setting_password_ug_popup_resp_cb,
 883                                           POPUP_INTERVAL, FALSE, FALSE);
 884 }
 885