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/title", &(passwordUG->itc_title));
 170         setting_create_Gendial_itc("dialogue/1icon",&(passwordUG->itc_variable_height));
 171         passwordUG->itc_seperator.item_style = "dialogue/separator";
 172         passwordUG->itc_seperator.func.text_get = NULL;
 173         passwordUG->itc_seperator.func.content_get = NULL;
 174         passwordUG->itc_seperator.func.state_get = NULL;
 175         passwordUG->itc_seperator.func.del = NULL;
 176
 177         passwordUG->itc_err_desc.item_style = "multiline/1text";
 178         passwordUG->itc_err_desc.func.text_get = __gl_err_desc_text_get;
 179         passwordUG->itc_err_desc.func.content_get = NULL;
 180         passwordUG->itc_err_desc.func.state_get = NULL;
 181         passwordUG->itc_err_desc.func.del = NULL;
 182
 183         /* init */
 184         passwordUG->view_type = __get_password_view_type(passwordUG, service);
 185         setting_tapi_init(passwordUG);
 186
 187         /*  creating a view. */
 188         setting_view_create(&setting_view_password_main,(void *)passwordUG);
 189         evas_object_event_callback_add(passwordUG->win_main_layout,
 190                                                EVAS_CALLBACK_RESIZE,
 191                                                setting_password_ug_cb_resize,
 192                                                passwordUG);
 193         return passwordUG->ly_main;
 194 }
 195
 196 static void setting_password_ug_on_start(ui_gadget_h ug, service_h service, void *priv)
 197 {
 198 }
 199
 200 static void setting_password_ug_on_pause(ui_gadget_h ug, service_h service, void *priv)
 201 {
 202 }
 203
 204 static void setting_password_ug_on_resume(ui_gadget_h ug, service_h service, void *priv)
 205 {
 206 }
 207
 208 static void setting_password_ug_on_destroy(ui_gadget_h ug, service_h service, void *priv)
 209 {
 210         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 211
 212         evas_object_event_callback_del(passwordUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_password_ug_cb_resize);       /* fix flash issue for gallery */
 213         passwordUG->ug = ug;
 214         setting_tapi_finize(passwordUG);
 215
 216         if (passwordUG->t_info) {
 217                 FREE(passwordUG->t_info);
 218         }
 219         if(passwordUG->remove_timer)
 220         {
 221                 ecore_timer_del(passwordUG->remove_timer);
 222                 passwordUG->remove_timer = NULL;
 223         }
 224
 225         /*  delete the allocated objects. */
 226         setting_view_destroy(&setting_view_password_main, passwordUG);
 227         if (NULL != ug_get_layout(passwordUG->ug)) {
 228                 evas_object_hide((Evas_Object *) ug_get_layout(passwordUG->ug));
 229                 evas_object_del((Evas_Object *) ug_get_layout(passwordUG->ug));
 230         }
 231 }
 232
 233 static void setting_password_ug_on_message(ui_gadget_h ug, service_h msg,
 234                                            service_h service, void *priv)
 235 {
 236
 237 }
 238
 239 static void setting_password_ug_on_event(ui_gadget_h ug,
 240                                          enum ug_event event, service_h service,
 241                                          void *priv)
 242 {
 243         if (!priv)
 244                 return;
 245
 246         SettingPasswordUG *ad = (SettingPasswordUG*)priv;
 247
 248         switch (event) {
 249         case UG_EVENT_LOW_MEMORY:
 250                 break;
 251         case UG_EVENT_LOW_BATTERY:
 252                 break;
 253         case UG_EVENT_LANG_CHANGE:
 254                 break;
 255         case UG_EVENT_ROTATE_PORTRAIT:
 256         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 257         case UG_EVENT_ROTATE_LANDSCAPE:
 258         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 259                 /* Focus entry */
 260                 SETTING_TRACE_DEBUG("get rotation event");
 261                 if(ad->ed_pw1)
 262                 {
 263                         if (ad->ed_pw1->isFocusFlag || (ad->ed_pw1->eo_check != NULL))
 264                         {
 265                                 SETTING_TRACE_DEBUG("set focus");
 266                                 /* no matter how many edifileds, it only need focus on 1st editfiled */
 267                                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 268                                 elm_entry_cursor_end_set(ad->ed_pw1->eo_check);
 269                         }
 270                 }
 271
 272                 break;
 273         case UG_EVENT_REGION_CHANGE:
 274                 break;
 275         default:
 276                 break;
 277         }
 278 }
 279
 280 static void setting_password_ug_on_key_event(ui_gadget_h ug,
 281                                              enum ug_key_event event,
 282                                              service_h service, void *priv)
 283 {
 284         if (!priv)
 285                 return;
 286
 287         SettingPasswordUG *ad = (SettingPasswordUG*)priv;
 288
 289         switch (event) {
 290         case UG_KEY_EVENT_END:
 291                 if(ad->remove_timer)
 292                 {
 293                         ecore_timer_del(ad->remove_timer);
 294                         ad->remove_timer = NULL;
 295                 }
 296                 ug_destroy_me(ug);
 297                 break;
 298         default:
 299                 break;
 300         }
 301 }
 302
 303 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 304 {
 305         SettingPasswordUG *passwordUG = calloc(1, sizeof(SettingPasswordUG));
 306         setting_retvm_if(!passwordUG, -1, "Create SettingPasswordUG obj failed");
 307
 308         ops->create = setting_password_ug_on_create;
 309         ops->start = setting_password_ug_on_start;
 310         ops->pause = setting_password_ug_on_pause;
 311         ops->resume = setting_password_ug_on_resume;
 312         ops->destroy = setting_password_ug_on_destroy;
 313         ops->message = setting_password_ug_on_message;
 314         ops->event = setting_password_ug_on_event;
 315         ops->key_event = setting_password_ug_on_key_event;
 316         ops->priv = passwordUG;
 317         ops->opt = UG_OPT_INDICATOR_ENABLE;
 318
 319         memset(passwordUG, 0x00, sizeof(SettingPasswordUG));
 320
 321         return 0;
 322 }
 323
 324 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 325 {
 326         SETTING_TRACE_BEGIN;
 327         struct SettingPasswordUG *passwordUG;
 328         setting_retm_if(!ops, "ops == NULL");
 329
 330         passwordUG = ops->priv;
 331         if (passwordUG)
 332                 FREE(passwordUG);
 333 }
 334
 335 void setting_get_sim_lock_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
 336 {
 337         SETTING_TRACE_BEGIN;
 338         ret_if(data == NULL || user_data == NULL);
 339
 340         TelSimPinOperationResult_t sec_rt = result;
 341         TelSimLockInfo_t *lock = data;
 342
 343         SettingPasswordUG *ad = (SettingPasswordUG *)user_data;
 344
 345         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);
 346
 347         char temp[256] ={0,};
 348         if(lock->retry_count > 1)
 349                 snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
 350         else if(lock->retry_count > 0)
 351                 snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
 352
 353         if(ad->err_desc)
 354         {
 355                 elm_object_item_del(ad->err_desc);
 356                 ad->err_desc = NULL;
 357         }
 358
 359         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), temp, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 360 }
 361
 362 void setting_get_pin_lock_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
 363 {
 364         SETTING_TRACE_BEGIN;
 365
 366         TelSimPinOperationResult_t sec_rt = result;
 367         TelSimLockInfo_t *lock = data;
 368
 369         SettingPasswordUG *ad = (SettingPasswordUG *)user_data;
 370
 371         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);
 372
 373         char temp[256] ={0,};
 374         if(lock->retry_count > 1)
 375                 snprintf(temp, 256, _(ATTEMPTS_DESC), lock->retry_count);
 376         else if(lock->retry_count > 0)
 377                 snprintf(temp, 256, _(ATTEMPT_DESC), lock->retry_count);
 378
 379         if(ad->err_desc)
 380         {
 381                 elm_object_item_del(ad->err_desc);
 382                 ad->err_desc = NULL;
 383         }
 384
 385         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), temp, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 386 }
 387
 388 void setting_sim_change_pins_cb(TapiHandle *handle, int result, void *data, void *user_data)
 389 {
 390         SETTING_TRACE_BEGIN;
 391         ret_if(!user_data || !data);
 392         TelSimPinOperationResult_t sec_rt = result;
 393         tapi_receive_info result_info = { 0, };
 394         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 395         SETTING_TRACE("sec_rt[%d]", sec_rt);
 396         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 397         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 398
 399         if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt) {
 400                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 401                         result_info.stat = SIM_PIN1_CHANGE_SUCCESS;
 402                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 403                         result_info.stat = SIM_PIN2_CHANGE_SUCCESS;
 404         } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 405                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 406                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 407                         result_info.retry_cnt = sim_event_data->retry_count;
 408                 } else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type) {
 409                         result_info.stat = SIM_INCORRECT_PIN2_CODE;
 410                         result_info.retry_cnt = sim_event_data->retry_count;
 411                 }
 412         } else if (TAPI_SIM_PUK_REQUIRED == sec_rt) {
 413                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 414                         result_info.stat = SIM_PIN1_BLOCKED;
 415                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 416                         result_info.stat = SIM_PIN2_BLOCKED;
 417         } else {
 418                 SETTING_TRACE_DEBUG
 419                     ("%s*** [ERR] INCORRECTED ***%s",
 420                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 421                 return;
 422         }
 423         setting_password_ug_display_result_popup(&result_info, user_data);
 424 }
 425
 426 void setting_sim_verify_puks_cb(TapiHandle *handle, int result, void *data, void *user_data)
 427 {
 428         SETTING_TRACE_BEGIN;
 429
 430         ret_if(!user_data || !data);
 431         SettingPasswordUG *ad = user_data;
 432         TelSimPinOperationResult_t sec_rt = result;
 433         tapi_receive_info result_info = { 0, };
 434         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 435         ad->verify_puks_result = sim_event_data;
 436         SETTING_TRACE("sec_rt[%d]", sec_rt);
 437         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 438         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 439
 440         if (TAPI_SIM_PTYPE_PUK1 == sim_event_data->type)
 441         {
 442                 //if (TAPI_SIM_PIN_REQUIRED == sec_rt){
 443                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 444                         SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
 445                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN1_UNBLOCKED")+1);
 446                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK1 Sucessfully"), TRUE);
 447                         return;
 448                 } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 449                         result_info.stat = SIM_INCORRECT_PUK1_CODE;
 450                         result_info.retry_cnt = sim_event_data->retry_count;
 451                 } else {
 452                         result_info.stat = SIM_UNKNOWN_ERROR;
 453                 }
 454         }
 455
 456         else if (TAPI_SIM_PTYPE_PUK2 == sim_event_data->type)
 457         {
 458                 //if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 459                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 460                         SETTING_TRACE_DEBUG("SIM_PIN2_UNBLOCKED");
 461                         safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_UNBLOCKED", sizeof("SETTING_PW_TYPE_PIN2_UNBLOCKED")+1);
 462                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK2 Sucessfully"), TRUE);
 463                         return;
 464                 } else if (TAPI_SIM_PUK_INCORRECT_PASSWORD == sec_rt) {
 465                         result_info.stat = SIM_INCORRECT_PUK2_CODE;
 466                         result_info.retry_cnt = sim_event_data->retry_count;
 467                 } else {
 468                         result_info.stat = SIM_UNKNOWN_ERROR;
 469                 }
 470         }
 471         else
 472         {
 473                 result_info.stat = SIM_UNKNOWN_ERROR;
 474         }
 475         setting_password_ug_display_result_popup(&result_info, user_data);
 476 }
 477
 478 void setting_sim_facility_enable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 479 {
 480         SETTING_TRACE_BEGIN;
 481         ret_if(!user_data || !data);
 482         TelSimPinOperationResult_t sec_rt = result;
 483         tapi_receive_info result_info = { 0, };
 484         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 485
 486         SETTING_TRACE("sec_rt[%d]", sec_rt);
 487         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 488         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 489
 490         /*  Sim Lock  */
 491         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 492                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_SIM == sim_event_data->type");
 493                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 494                         result_info.stat = SIM_LOCK_ON_SUCCESS;
 495                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 496                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 497                 else {
 498                         SETTING_TRACE_DEBUG("%s*** [ERR] INCORRECTED ***%s",
 499                              SETTING_FONT_RED,
 500                              SETTING_FONT_BLACK);
 501                         return;
 502                 }
 503         }
 504         /*  Pin Lock */
 505         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 506                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_PIN1 == sim_event_data->type");
 507                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 508                         result_info.stat = SIM_PIN_LOCK_ON_SUCCESS;
 509                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 510                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 511                         result_info.retry_cnt = sim_event_data->retry_count;
 512                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 513                         result_info.stat = SIM_PIN1_BLOCKED;
 514
 515                 /*  Pre CCF */
 516                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 517                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 518                         /*  popup */
 519                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 520                 }
 521                 else {
 522                         SETTING_TRACE_DEBUG
 523                             ("%s*** [ERR] INCORRECTED ***%s",
 524                              SETTING_FONT_RED,
 525                              SETTING_FONT_BLACK);
 526                         return;
 527                 }
 528         }
 529         setting_password_ug_display_result_popup(&result_info, user_data);
 530 }
 531 void setting_sim_facility_disable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 532 {
 533         SETTING_TRACE_BEGIN;
 534         ret_if(!user_data || !data);
 535         TelSimPinOperationResult_t sec_rt = result;
 536         tapi_receive_info result_info = { 0, };
 537         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 538         SETTING_TRACE("sec_rt[%d]", sec_rt);
 539         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 540         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 541
 542         /*  Sim Lock  */
 543         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 544                 SETTING_TRACE_DEBUG("SIM lOCK");
 545                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 546                         result_info.stat = SIM_LOCK_OFF_SUCCESS;
 547                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 548                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 549                 else {
 550                         SETTING_TRACE_DEBUG
 551                             ("%s*** [ERR] INCORRECTED ***%s",
 552                              SETTING_FONT_RED,
 553                              SETTING_FONT_BLACK);
 554                         return;
 555                 }
 556         }
 557         /*  Pin Lock */
 558         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 559                 SETTING_TRACE_DEBUG("PIN LOCK");
 560                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 561                         result_info.stat = SIM_PIN_LOCK_OFF_SUCCESS;
 562                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 563                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 564                         result_info.retry_cnt = sim_event_data->retry_count;
 565                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 566                         result_info.stat = SIM_PIN1_BLOCKED;
 567
 568                 /*  Pre CCF */
 569                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 570                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 571                         /*  popup */
 572                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 573                 }
 574                 else {
 575                         SETTING_TRACE_DEBUG
 576                             ("%s*** [ERR] INCORRECTED ***%s",
 577                              SETTING_FONT_RED,
 578                              SETTING_FONT_BLACK);
 579                         return;
 580                 }
 581         }
 582         setting_password_ug_display_result_popup(&result_info, user_data);
 583 }
 584
 585 static void setting_password_ug_display_result_popup(tapi_receive_info *result,
 586                                                      SettingPasswordUG *ad)
 587 {
 588         SETTING_TRACE_BEGIN;
 589         switch (result->stat) {
 590         case SIM_OPERATION_OK:
 591         case SIM_LOCK_ON_SUCCESS:
 592         case SIM_LOCK_OFF_SUCCESS:
 593         case SIM_PIN_LOCK_ON_SUCCESS:
 594         case SIM_PIN_LOCK_OFF_SUCCESS:
 595                 {
 596                         if (ad->view_type ==
 597                             SETTING_PW_TYPE_SIM_LOCK_OFF) {
 598                                 int err = SETTING_RETURN_SUCCESS;
 599                                 /*  reset VCONF */
 600                                 setting_set_int_slp_key
 601                                     (INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,
 602                                      SIM_LOCK_ATTEMPS_MAX, &err);
 603                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 604                                                 "[Error] set value of vconf fail.");
 605                         }
 606                         /*  Success to Operate */
 607                         service_h svc;
 608                         if (service_create(&svc))
 609                                 return;
 610
 611                         service_add_extra_data(svc, "result", ad->view_type_string);
 612                         ug_send_result(ad->ug, svc);
 613                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 614
 615                         service_destroy(svc);
 616                         /* Send destroy request */
 617                         ug_destroy_me(ad->ug);
 618                 }
 619                 break;
 620         case SIM_LOCK_INCORRECT_PASSWORD:
 621                 {
 622                         SETTING_TRACE_DEBUG("SIM LOCK INCORRECT PASSWORD");
 623                         ad->focus_data = ad->ed_pw1;
 624                         setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 625                 }
 626                 break;
 627         case SIM_INCORRECT_PIN1_CODE:
 628                 {
 629                         const char *ret_str = NULL;
 630                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 631
 632                         if (result->retry_cnt > 1) {
 633                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 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                         } else {
 638                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 639                                 setting_retm_if(ret < 0, "snprintf fail");
 640                                 ret_str = tmp_str;
 641                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 642                         }
 643                         ad->focus_data = ad->ed_pw1;
 644
 645                         setting_password_ug_display_desc(ad, (char *)ret_str, FALSE);
 646
 647                 }
 648                 break;
 649         case SIM_INCORRECT_PIN2_CODE:
 650                 {
 651                         char *ret_str = NULL;
 652                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 653
 654                         if (result->retry_cnt > 1) {
 655                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 656                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 657                                 setting_retm_if(ret < 0, "snprintf fail");
 658                                 ret_str = tmp_str;
 659                         } else {
 660                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1_ATTEMPT_LEFT");
 661                         }
 662                         ad->focus_data = ad->ed_pw1;
 663
 664                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 665
 666                 }
 667                 break;
 668         case SIM_INCORRECT_PUK1_CODE:
 669                 {
 670                         char *ret_str = NULL;
 671                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 672
 673                         if (result->retry_cnt > 1) {
 674                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK1_PD_ATTEMPTS_LEFT', must transform */
 675                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK1_ERR_DESC, result->retry_cnt);
 676                                 setting_retm_if(ret < 0, "snprintf fail");
 677                                 ret_str = tmp_str;
 678                         } else {
 679                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK1_CODE");
 680                         }
 681                         ad->focus_data = ad->ed_pw1;
 682
 683                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 684
 685                 }
 686                 break;
 687         case SIM_INCORRECT_PUK2_CODE:
 688                 {
 689                         char *ret_str = NULL;
 690                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 691                         if (result->retry_cnt > 1) {
 692                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK2_PD_ATTEMPTS_LEFT', must transform*/
 693                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK2_ERR_DESC, result->retry_cnt);
 694                                 setting_retm_if(ret < 0, "snprintf fail");
 695                                 ret_str = tmp_str;
 696                         } else {
 697                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK2");
 698                         }
 699                         ad->focus_data = ad->ed_pw1;
 700
 701                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 702
 703                 }
 704                 break;
 705         case SIM_PIN1_CHANGE_SUCCESS:
 706                 setting_password_ug_create_popup_notitle_nobtn(ad,
 707                                                                _("IDS_ST_POP_PIN1_CHANGED"), TRUE);
 708                 break;
 709         case SIM_PIN2_CHANGE_SUCCESS:
 710                 setting_password_ug_create_popup_notitle_nobtn(ad,
 711                                                                _("IDS_ST_POP_PIN2_CHANGED"), TRUE);
 712                 break;
 713         case SIM_PIN1_BLOCKED:
 714                 SETTING_TRACE_DEBUG("SIM_PIN1_BLOCKED");
 715                 ad->view_type = SETTING_PW_TYPE_PIN1_BLOCKED;
 716                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN1_BLOCKED")+1);
 717                 setting_password_ug_create_popup_notitle_nobtn(ad,
 718                                                                _("IDS_ST_POP_PIN1_BLOCKED"), FALSE);
 719                 break;
 720         case SIM_PIN2_BLOCKED:
 721                 SETTING_TRACE_DEBUG("SIM_PIN2_BLOCKED");
 722                 ad->view_type = SETTING_PW_TYPE_PIN2_BLOCKED;
 723                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN2_BLOCKED", safeStrLen("SETTING_PW_TYPE_PIN2_BLOCKED")+1);
 724                 setting_password_ug_create_popup_notitle_nobtn(ad,
 725                                                                _("IDS_ST_POP_PIN2_BLOCKED"), FALSE);
 726                 break;
 727         case SIM_PIN1_UNBLOCKED:
 728                 SETTING_TRACE_DEBUG("SIM_PIN1_UNBLOCKED");
 729                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN_LOCK_ON", sizeof("SETTING_PW_TYPE_PIN_LOCK_ON")+1);
 730                 setting_password_ug_create_popup_notitle_nobtn(ad,
 731                                                                _("IDS_ST_POP_PIN_UNBLOCKED"), TRUE);
 732                 break;
 733         case SIM_PIN2_UNBLOCKED:
 734                 setting_password_ug_create_popup_notitle_nobtn(ad,
 735                                                                _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
 736                 break;
 737         case SIM_PUK1_BLOCKED:
 738                 setting_password_ug_create_popup_notitle_nobtn(ad,
 739                                        _("IDS_ST_BODY_PUK1_BLOCKED"), TRUE);
 740                 /*  Phone blocked. Call Permernent UG */
 741                 break;
 742         case SIM_PUK2_BLOCKED:
 743                 setting_password_ug_create_popup_notitle_nobtn(ad,
 744                                        _("IDS_ST_BODY_PUK2_BLOCKED"), TRUE);
 745                 /*  Call Permernent UG */
 746                 break;
 747         case SIM_REQUIRED_PUK_CODE:
 748                 SETTING_TRACE_DEBUG("SIM_REQUIRED_PUK_CODE");
 749                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_PIN1_BLOCKED", sizeof("SETTING_PW_TYPE_PIN1_BLOCKED")+1);
 750                 setting_password_ug_create_popup_notitle_nobtn(ad,
 751                                        _("IDS_ST_POP_PIN1_BLOCKED"), TRUE);
 752                 break;
 753         case SIM_OPERATION_UNAVAILABLE:
 754                 setting_password_ug_create_popup_notitle_nobtn(ad,
 755                                        _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
 756                 break;
 757         case SIM_UNKNOWN_ERROR:
 758                 setting_password_ug_create_popup_notitle_nobtn(ad,
 759                                        _("IDS_ST_POP_UNKNOWN_OPERATION"), FALSE);
 760                 break;
 761         case SIM_ERROR:
 762         case SIM_REQ_PIN:
 763         case SIM_OPERATION_OFF:
 764         case SIM_LOCK_ON_FAIL:
 765                 SETTING_TRACE_DEBUG("SIM_LOCK_ON_FAIL");
 766                 {
 767                         int err = SETTING_RETURN_SUCCESS;
 768
 769                         if(result->retry_cnt > 0)
 770                         {
 771                                 setting_password_ug_display_desc(ad, PW_ERR_DESC, FALSE);
 772                         }
 773                         else
 774                         {
 775                                 char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 776                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
 777                                 safeCopyStr(ad->view_type_string, "SETTING_PW_TYPE_SIM_LOCK_DISABLE", sizeof("SETTING_PW_TYPE_SIM_LOCK_DISABLE")+1);
 778                                 setting_password_ug_create_popup_notitle_nobtn(ad, tmp_str, TRUE);
 779                         }
 780                 }
 781                 break;
 782         case SIM_PIN1_CHANGE_FAIL:
 783         case SIM_PIN2_CHANGE_FAIL:
 784                 setting_password_ug_create_popup_notitle_nobtn(ad,
 785                                        _("Change Failed"), TRUE);
 786                 break;
 787         default:
 788                 break;
 789         }
 790
 791         SETTING_TRACE_END;
 792 }
 793
 794 void setting_password_ug_popup_resp_cb(void *data, Evas_Object *obj,
 795                                        void *event_info)
 796 {
 797         retm_if(data == NULL, "Data parameter is NULL");
 798
 799         service_h svc;
 800         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 801         if (ad->destroy) {
 802                 /*  Success to Operate */
 803
 804                 if (service_create(&svc))
 805                         return;
 806
 807                 service_add_extra_data(svc, "result", ad->view_type_string);
 808                 ug_send_result(ad->ug, svc);
 809                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 810
 811                 service_destroy(svc);
 812                 /* Send destroy request */
 813                 ug_destroy_me(ad->ug);
 814         } else {
 815                 char *diable_view_type = NULL;
 816                 if (ad->view_type == SETTING_PW_TYPE_PIN1_BLOCKED)
 817                 {
 818                         setting_view_destroy(&setting_view_password_main, ad);
 819                         setting_view_create(&setting_view_password_main, ad);
 820                         return;
 821                 }
 822                 else if (ad->view_type == SETTING_PW_TYPE_PIN2_BLOCKED)
 823                 {
 824                         setting_view_destroy(&setting_view_password_main, ad);
 825                         setting_view_create(&setting_view_password_main, ad);
 826                         return;
 827                 }
 828
 829                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
 830                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
 831                 }
 832
 833                 if (diable_view_type) {
 834                         /*  Success to Operate */
 835
 836                         if (service_create(&svc))
 837                                 return;
 838
 839                         service_add_extra_data(svc, "result", diable_view_type);
 840                         ug_send_result(ad->ug, svc);
 841
 842                         service_destroy(svc);
 843                         /* Send destroy request */
 844                         ug_destroy_me(ad->ug);
 845                 }
 846                 if (ad->focus_data) {
 847                         ad->focus_data->isFocusFlag = TRUE;
 848                         elm_object_item_data_set(ad->focus_data->item, ad->focus_data);
 849                         elm_genlist_item_update(ad->focus_data->item);
 850                 }
 851         }
 852 }
 853 static Eina_Bool __remove_desc(void *data)
 854 {
 855         SETTING_TRACE_BEGIN;
 856         retv_if(data == NULL, EINA_FALSE);
 857
 858         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 859
 860         if(ad->err_desc)
 861         {
 862                 elm_object_item_del(ad->err_desc);
 863                 ad->err_desc = NULL;
 864         }
 865
 866         if(ad->remove_timer)
 867         {
 868                 ecore_timer_del(ad->remove_timer);
 869                 ad->remove_timer = NULL;
 870         }
 871
 872         if (ad->destroy) {
 873                 /*  Success to Operate */
 874
 875                 service_h svc;
 876                 if (service_create(&svc))
 877                         return EINA_FALSE;
 878
 879                 service_add_extra_data(svc, "result", ad->view_type_string);
 880                 ug_send_result(ad->ug, svc);
 881                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 882
 883                 service_destroy(svc);
 884                 /* Send destroy request */
 885                 ug_destroy_me(ad->ug);
 886         } else {
 887                 char *diable_view_type = NULL;
 888                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
 889                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
 890                 }
 891
 892                 if (diable_view_type) {
 893                         /*  Success to Operate */
 894
 895                         service_h svc;
 896                         if (service_create(&svc))
 897                                 return EINA_FALSE;
 898
 899                         service_add_extra_data(svc, "result", diable_view_type);
 900                         ug_send_result(ad->ug, svc);
 901
 902                         service_destroy(svc);
 903                         /* Send destroy request */
 904                         ug_destroy_me(ad->ug);
 905                 }
 906         }
 907         return ECORE_CALLBACK_CANCEL;
 908 }
 909
 910 void setting_password_ug_display_desc(void *data, char *desc, int destroy)
 911 {
 912         SETTING_TRACE_BEGIN;
 913         ret_if(data == NULL || desc == NULL);
 914
 915         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 916
 917 #ifdef SUPPORT_MDM
 918         if(ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
 919                 return;
 920 #endif
 921
 922         ad->destroy = destroy;
 923
 924         if(ad->scroller == NULL)
 925                 return;
 926
 927         if(ad->err_desc)
 928         {
 929                 elm_object_item_del(ad->err_desc);
 930                 ad->err_desc = NULL;
 931         }
 932
 933         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), desc, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 934         ad->remove_timer = ecore_timer_add(2.0, __remove_desc, ad);
 935
 936         /* if pw incorrect, show keyboard again. */
 937         if(ad->ed_pw1)
 938         {
 939                 SETTING_TRACE_DEBUG("FOCUS IN");
 940                 ad->ed_pw1->isFocusFlag = TRUE;
 941                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
 942         }
 943 }
 944
 945 void
 946 setting_password_ug_create_popup_notitle_nobtn(void *data, char *str,
 947                                                int destroy)
 948 {
 949         /* error check */
 950         retm_if(data == NULL, "Data parameter is NULL");
 951
 952         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 953
 954         ad->destroy = destroy;
 955         if(ad->notify)
 956         {
 957                 evas_object_del(ad->notify);
 958                 ad->notify = NULL;
 959         }
 960         ad->notify = setting_create_popup_without_btn(ad, ad->ly_main, NULL, str,
 961                                           setting_password_ug_popup_resp_cb,
 962                                           POPUP_INTERVAL, FALSE, FALSE);
 963 }
 964