setting-password/src/setting-password.c

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